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 |
|---|---|---|---|---|---|---|
Adds underscores to all ids and classes
|
def prefix_css_selectors(prefix = "_")
selector_regex = /^\s*?(?!\/\*)+?[^:]*?(?!:\s)([\.#][^,\s]*[:]?[^\s,])$/
new_sass = ""
sass.each_line do |line|
# Skip blank lines
next if line =~ /^\s*$/
line = line.gsub(selector_regex) do |str|
# Add the underscores
str.gsub!(/([#.])/, "\\1#{prefix}")
end
new_sass << line
end
sass = new_sass
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def underscore(class_name)\n class_name.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def id\n super.to_s.tr('.', '_')\n end",
"def underscore\n class_name.to_s.underscore\n end",
"def underscore\n Bodhi::Support.underscore(self.class.name)\n end",
"def id_attribute_for(class_name)\n class_name = class_name.match(/([^:]+)$/)[1]\n class_name.gsub!(/([A-Z])([A-Z][a-z])/, '\\1_\\2')\n class_name.gsub!(/([a-z])([A-Z])/, '\\1_\\2')\n\n \"#{class_name.downcase}_id\"\n end",
"def underscore\n gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2').gsub(/([a-z\\d])([A-Z])/, '\\1_\\2').tr('-', '_').downcase\n end",
"def underscore\n self.to_s.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def underscore\n gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2').\n gsub(/([a-z\\d])(A-Z)/, '\\1_\\2').\n tr('-', '_').downcase\n end",
"def underscore\n\t self.to_s.gsub(/::/, '/').\n\t gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n\t gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n\t tr(\"-\", \"_\").\n\t downcase\n\tend",
"def underscore\n\t self.to_s.gsub(/::/, '/').\n\t gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n\t gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n\t tr(\"-\", \"_\").\n\t downcase\n\tend",
"def underscore\n self.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def underscore\n new_string = gsub(NAMESPACE_SEPARATOR, UNDERSCORE_SEPARATOR)\n new_string.gsub!(/([A-Z\\d]+)([A-Z][a-z])/, UNDERSCORE_DIVISION_TARGET)\n new_string.gsub!(/([a-z\\d])([A-Z])/, UNDERSCORE_DIVISION_TARGET)\n new_string.gsub!(/[[:space:]]|\\-/, UNDERSCORE_DIVISION_TARGET)\n new_string.downcase!\n self.class.new new_string\n end",
"def id\n name.gsub /-/, '_'\n end",
"def underscore\n self.dup.underscore!\n end",
"def underscore(klass)\n return klass unless /::/.match?(klass)\n\n word = klass.to_s.gsub('::'.freeze, '.'.freeze)\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/, '\\1_\\2'.freeze)\n word.gsub!(/([a-z\\d])([A-Z])/, '\\1_\\2'.freeze)\n word.downcase!\n word\n end",
"def underscore_name\n @underscore_name ||= self.class.name\n .split('::')\n .last\n .gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')\n .gsub(/([a-z\\d])([A-Z])/, '\\1_\\2')\n .tr('-', '_')\n .downcase\n end",
"def underscore\n dup.underscore!\n end",
"def make_id\n \"#{self.class.name.downcase}#{id}\"\n end",
"def underscorize\n self.gsub(\" \",\"_\")\n end",
"def underscore code\n code.\n gsub(/\\bload\\b/, '_load').\n gsub(/\\brels\\b/, '_rels').\n gsub(/\\bnode\\b/, '_node')\n end",
"def underscore!\n gsub!('::', '_')\n gsub!(/([A-Z\\d]+)([A-Z][a-z])/, '\\1_\\2')\n gsub!(/([a-z\\d])([A-Z])/, '\\1_\\2')\n downcase!\n end",
"def model_html_id(base)\n name = base.to_s.strip\n unless name.end_with?(*RESERVED_SUFFIX)\n FIELD_PREFIX.find { |prefix| name.delete_prefix!(prefix) }\n end\n name = 'None' if name.blank?\n html_id(name, camelize: true)\n end",
"def underscore\n word = self.dup\n word.gsub!(/::/, '/')\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.downcase!\n word\n end",
"def identifier\n name.gsub(/[^A-Za-z0-9_]/, '_')\n end",
"def identifier\n name.gsub(/[^A-Za-z0-9_]/, '_')\n end",
"def id_fragment\n return ActiveSupport::Inflector.demodulize(self.class.name)\n end",
"def to_id\n\t\treturn self.\n\t\t\tgsub(\"::\", \"\").\n\t\t\tgsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n\t\t\tgsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n\t\t\tdowncase.\n\t\t\tgsub(\"_\", \"-\")\n\tend",
"def underscore(text)\n text.gsub(/[a-z0-9][A-Z]/) do |match|\n match[0,1] + '_' + match[1,1].downcase\n end\n end",
"def identifier_method_name #:nodoc:\n short_identifier.gsub(/[^a-z0-9_]/, '_')\n end",
"def underscore_name(name)\n name.to_s.sub(/.*::/, \"\").\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def name_with_underscores\n name.gsub(\" \", \"_\")\n end",
"def generate_id(v)\n @collection_id + '-' + v.downcase.gsub(/\\/+/, '_').gsub(/;+|\\.+/, '').gsub(/ /, '-')\n end",
"def underscore\n\t\tcamel_cased_word = self\n\t\tword = camel_cased_word.to_s.dup\n\t\tword.gsub!(/::/, '/')\n#\t\tword.gsub!(/(?:([A-Za-z\\d])|^)(#{inflections.acronym_regex})(?=\\b|[^a-z])/) { \"#{$1}#{$1 && '_'}#{$2.downcase}\" }\n\t\tword.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n\t\tword.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n\t\tword.tr!(\"-\", \"_\")\n\t\tword.downcase!\n\t\tword\n\tend",
"def create_html_id\n self.html_id = title.blank? ? \"element-unnamed\" : title.downcase.gsub!(/[^a-zA-Z0-9\\-_]+/, '-')\n end",
"def convert_class(klass)\n ::ActiveSupport::Inflector.underscore(klass.name).gsub(\"/\", \"_\")\n end",
"def dom_id\n \"#{self.class.name.gsub(/:+/,\"_\")}_#{self.object_id}\"\n end",
"def sub_id() @tag.sub( /.*_/, '' ) end",
"def sub_id() @tag.sub( /.*_/, '' ) end",
"def to_underscore(string)\n string.to_s.gsub(/([A-Z][A-Z0-9]?)/) { '_' + $1.downcase }.gsub(/^_|\\s_/, ' ').gsub(/^\\s/, '')\nend",
"def ns_underscore\n to_s.underscore.gsub('/', '__')\n end",
"def css_id(model)\n \"#{model.class.to_s.downcase}#{model.id}\"\n end",
"def dom_id(object, prefix=nil)\n \"#{prefix ? prefix.to_s + '_' : nil}#{object.class.name}_#{object.id}\"\n end",
"def name_underscored\n self.name.gsub(' ', '_')\n end",
"def class_name()\n return self.id.downcase.gsub(/\\Ah?l_/i, \"\")\n end",
"def underscore(const_name)\n const_name.gsub(/([^\\^])([A-Z])/,'\\1_\\2').downcase.to_sym\n end",
"def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)\n underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? \"_id\" : \"id\")\n end",
"def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)\n underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? \"_id\" : \"id\")\n end",
"def css_id name\n attr \"##{name}\"\n end",
"def to_underscore\n downcase.gsub(%r{/}, '_')\n end",
"def underscore(s)\n s.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/, '\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def underscore(camel_cased_word)\n #2 replaces any double colons with a slash using gsub\n # string = \"SomeModule::SomeClass\".gsub(/::/, '/')\n string = camel_cased_word.gsub(/::/, '/') #=> \"SomeModule/SomeClass\"\n #3 inserts an underscore between any all-caps class prefixes (like acronyms) and other words\n string.gsub!(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2') #=> nil\n #4 inserts an underscore between any camelcased words\n string.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2') #=> \"Some_Module/Some_Class\"\n #5 replaces any - with _ by using tr method\n string.tr!(\"-\", \"_\") #=> nil\n #6 makes the string lowercase\n string.downcase #=> \"some_module/some_class\"\n end",
"def safe_class_name()\n self.class.name.downcase.gsub(/[^\\d\\w]/, '_')\n end",
"def css_id *a; CssString.new a.flatten.unshift(self).join '#' end",
"def dom_id(object)\n object.class.to_s.tableize + '_' + object.id.to_s\n end",
"def underscore(string)\n string.gsub('::', '_')\n .gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')\n .gsub(/([a-z\\d])([A-Z])/, '\\1_\\2')\n .tr('-', '_')\n .downcase\n end",
"def underscore(camel_cased_word)\n word = camel_cased_word.to_s.gsub('::', '/')\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.downcase!\n word\n end",
"def generate_identifier\n self.identifier ||= self.name.parameterize.underscore\n end",
"def underscore_vars\r\n self.gsub(/\\b[a-z][a-z]*(?:[A-Z][a-z]*)(?:[A-Z][a-z]*)*\\b/) {|word|\r\n word.underscore\r\n }\r\n end",
"def underscore(camel_cased_word)\n camel_cased_word.to_s.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def to_underscore(s)\n s.gsub(/\\.|\\-/, '__')\n end",
"def namespaced_id(field)\n \"#{namespaces.join('_')}#{'_' unless namespaces.empty?}#{field}\"\n end",
"def generate\n base_name = camel_case identifier.to_s\n decorate_klass_name base_name\n end",
"def underscore(str)\n str.gsub(/.*::/,'').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def underscore(str) # :doc:\n str.to_s. # allow symbols and strings\n gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2'). # underscore-delimit caps\n gsub(/([a-z\\d])\\s?([A-Z])/, '\\1_\\2'). # underscore-delimit words\n tr(\"-\", \"_\"). # dashes to underscores\n downcase. # everything lowercase\n to_sym # convert to symbol\n end",
"def prefix\n p = nil\n params.each { |k,v|\n if (k[-1,1] == \"_\") && (k[0,1] =~ /[A-Z]/)\n\tp = k\n\tbreak\n end\n }\n all_classes = WsCim::constants\n if p == \"CIM_\"\n @classes = all_classes.reject { |c| c =~ /_/ }\n elsif p\n @classes = all_classes.grep( Regexp.new( \"^#{p}\" ) )\n end\n @classes.sort!\n render(:partial => \"browse_class_prefix\", :layout => false)\n end",
"def underscore(camel_cased_word)\n camel_cased_word.to_s.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").downcase\n end",
"def underscore(camel_cased_word)\n word = camel_cased_word.to_s.dup\n word.gsub!('::', '/')\n word.gsub!(/(?:([A-Za-z\\d])|^)((?=a)b)(?=\\b|[^a-z])/) { \"#{$1}#{$1 && '_'}#{$2.downcase}\" }\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.downcase!\n word\n end",
"def generate_html_id(method_name, value='input') #:nodoc:\n index = if options.has_key?(:index)\n options[:index]\n elsif defined?(@auto_index)\n @auto_index\n else\n \"\"\n end\n sanitized_method_name = method_name.to_s.gsub(/[\\?\\/\\-]$/, '')\n\n [custom_namespace, sanitized_object_name, index, sanitized_method_name, value].reject{|x|x.blank?}.join('_')\n end",
"def underscore(camel_cased_word)\n word = camel_cased_word.to_s.dup\n word.gsub!(/::/, '/')\n word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.downcase!\n word\n end",
"def underscore(camel_cased_word)\n word = camel_cased_word.to_s.dup\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.tr!(\"[\", \"_\")\n word.tr!(\"]\", \"\")\n word.downcase!\n word\n end",
"def id\n @id || self.class.name.underscore.split('/').last #gsub('/', '_')\n end",
"def underscore(camel_cased_word)\n\tcamel_cased_word.to_s.gsub(/::/, '/').\n\t gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n\t gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n\t tr(\"-\", \"_\").\n\t downcase + \"s\"\nend",
"def underscore_string(str)\n str.to_s.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def name_2_id( a_string ) \n return a_string.gsub(\"[\",\"_\").gsub(\"]\",\"\");\n end",
"def gen_inst_id_str(inst_str)\n return inst_str.gsub(/[\\.:\\[\\]]/,'_').upcase\nend",
"def get_unique_dom_id( prefix, target_datetime )\n \"#{prefix}_#{target_datetime}\".gsub(/[òàèùçé^!\"'£$%&?.,;:§°<>]/,'').gsub(/[\\s|]/,'_').gsub(/[\\\\\\/=]/,'-')\n end",
"def class_name_to_attribute_name(name)\r\n name.gsub(/([a-z]+)([A-Z])/, '\\1_\\2').gsub('-', '_').downcase\r\n end",
"def class_name_to_attribute_name(name)\r\n name.gsub(/([a-z]+)([A-Z])/, '\\1_\\2').gsub('-', '_').downcase\r\n end",
"def humanize(lower_case_and_underscored_word)\n lower_case_and_underscored_word.to_s.gsub(/_id$/, '').tr('_', ' ').capitalize\n end",
"def underscore(camel_cased_word)\n camel_cased_word.to_s.gsub(/(.)([A-Z])/, '\\1_\\2').downcase\n end",
"def underscore(camel_cased_word)\n word = camel_cased_word.to_s.dup\n word.gsub!(/::/, '/')\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.downcase!\n word\n end",
"def underscore(camel_cased_word)\n camel_cased_word.to_s.gsub(/::/, '/')\n .gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2')\n .gsub(/([a-z\\d])([A-Z])/,'\\1_\\2')\n .tr(\"-\", \"_\")\n .downcase\n end",
"def underscore(camel_cased_word)\n return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)\n\n word = camel_cased_word.to_s.gsub('::', '/')\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/, '\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/, '\\1_\\2')\n word.tr!('-', '_')\n word.downcase!\n word\n end",
"def underscore(camel_cased_word)\n camel_cased_word.to_s.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def html_friendly\n\t\tself.to_s.downcase.gsub(/\\W/,'_').gsub(/_+/,'_')\n\tend",
"def dom_id\n \"_#{self.object_id}\"\n end",
"def html_id(record)\n \"#{record.class.name.underscore}_#{record[:id].to_i}\"\n end",
"def humanize(lower_case_and_underscored_word)\n lower_case_and_underscored_word.to_s.gsub(/_id$/, \"\").gsub(/_/, \" \").capitalize\n end",
"def underscore(camel_cased_word)\n camel_cased_word.to_s.\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def underscore(str)\n str = require_string! str\n\n inflector.underscore(str)\n end",
"def underscore(word)\n word.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def dom_id\n display_id = new_record? ? \"new\" : id\n prefix = prefix.nil? ? self.class.name.underscore : \"#{prefix}_#{self.class.name.underscore}\"\n prefix.gsub!('/', '_')\n \"#{prefix}_#{display_id}\"\n end",
"def sanitize_class_name(name)\n name.gsub(/[^_0-9A-Za-z:]/, '')\n end",
"def underscore(str)\n str.to_s.gsub(/\\B[A-Z](?:[a-z])/, '_\\&').downcase\n end",
"def makena_classes_u_p_sym\n makena_classes_u.map{|a| a.underscore.pluralize.to_sym}\n end",
"def to_underscore(string)\n string.gsub(/(.)([A-Z])/,'\\1_\\2').downcase\nend",
"def fix_id(id, format, extra)\n id << \".\" + format if !format.blank?\n id << \".\" + extra if !extra.blank?\n return id\n end",
"def underscore(string)\n string.gsub(/::/, '/').\n gsub(/([A-Z]+)([A-Z][a-z])/,'\\1_\\2').\n gsub(/([a-z\\d])([A-Z])/,'\\1_\\2').\n tr(\"-\", \"_\").\n downcase\n end",
"def underscore(name)\r\n s = name[0].downcase\r\n name[1,name.length].each_char do |ch|\r\n s += (ch.match(/[^A-Z]/) ? ch : \"_\"+ch.downcase)\r\n end\r\n return s\r\n end",
"def underscore_fix_for_related_urls(key)\n if key == 'RelatedURLs'\n 'related_urls'\n else\n key.underscore\n end\n end",
"def underscored_name(word = self.class.to_s)\n @underscored_name ||= begin\n words = word.dup.split('::')\n word = words.last\n if word == 'Panel'\n word = words[-2] # Panel class is Panel... and this won't do.\n end\n # This bit from rails probably isn't needed here, and wouldn't work anyways.\n #word.gsub!(/(?:([A-Za-z\\d])|^)(#{inflections.acronym_regex})(?=\\b|[^a-z])/) { \"#{$1}#{$1 && '_'}#{$2.downcase}\" }\n word.gsub!(/Panel$/,'')\n word.gsub!(/([A-Z\\d]+)([A-Z][a-z])/,'\\1_\\2')\n word.gsub!(/([a-z\\d])([A-Z])/,'\\1_\\2')\n word.tr!(\"-\", \"_\")\n word.downcase!\n word\n end\n end"
] |
[
"0.6998579",
"0.67214453",
"0.665972",
"0.6657908",
"0.6646169",
"0.6638016",
"0.6460274",
"0.6432089",
"0.64223313",
"0.64223313",
"0.6405076",
"0.6368335",
"0.63256145",
"0.62615126",
"0.6243535",
"0.6208079",
"0.6168025",
"0.615419",
"0.61436385",
"0.613395",
"0.6108174",
"0.60891193",
"0.6078074",
"0.60508406",
"0.60508406",
"0.6045931",
"0.6010034",
"0.6002109",
"0.5968126",
"0.5965097",
"0.5962546",
"0.5924479",
"0.5917352",
"0.5889985",
"0.5872626",
"0.58563125",
"0.5854644",
"0.5854644",
"0.5844552",
"0.5836642",
"0.58090705",
"0.58086544",
"0.58055556",
"0.5805057",
"0.57919717",
"0.5790288",
"0.5790288",
"0.5787368",
"0.57693034",
"0.5757464",
"0.57495844",
"0.57250243",
"0.5711426",
"0.5702791",
"0.5700394",
"0.5699731",
"0.56995845",
"0.5692389",
"0.568781",
"0.56794196",
"0.56703764",
"0.5661066",
"0.5660014",
"0.56465083",
"0.56343997",
"0.56299704",
"0.56289595",
"0.5624006",
"0.5621738",
"0.5618583",
"0.56056",
"0.5599487",
"0.5597893",
"0.5596363",
"0.5593726",
"0.55911463",
"0.55851364",
"0.55851364",
"0.5579704",
"0.55741256",
"0.5571264",
"0.55667347",
"0.55638665",
"0.55635935",
"0.5559496",
"0.5558743",
"0.55584395",
"0.55557966",
"0.55466896",
"0.5538563",
"0.55352354",
"0.5529982",
"0.5522951",
"0.5518416",
"0.55177337",
"0.5504941",
"0.5501603",
"0.54982424",
"0.54937446",
"0.549363",
"0.54915106"
] |
0.0
|
-1
|
rewrite internal paths to normalized paths
|
def normalize_paths
new_sass = ""
sass.each_line do |line|
line = SassLine.new(@epub, self, line)
line.normalize_paths if line.has_path?
new_sass += "#{line.to_s}\n"
end
self.sass = new_sass
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def normalize_path(path); end",
"def normalize_path(path); end",
"def normalize(path)\n path.gsub(/\\\\/, \"/\")\n end",
"def normalize_paths(paths)\n # do the hokey-pokey of path normalization...\n paths = paths.collect do |path|\n path = path.\n gsub(\"//\", \"/\"). # replace double / chars with a single\n gsub(\"\\\\\\\\\", \"\\\\\"). # replace double \\ chars with a single\n gsub(%r{(.)[\\\\/]$}, '\\1') # drop final / or \\ if path ends with it\n\n # eliminate .. paths where possible\n re = %r{[^/\\\\]+[/\\\\]\\.\\.[/\\\\]}\n path.gsub!(re, \"\") while path.match(re)\n path\n end\n\n # start with longest path, first\n paths = paths.uniq.sort_by { |path| - path.length }\n end",
"def normalize_path(path)\n path.sub(%r{^/}, '').tr('', '')\n end",
"def normalize_path(path)\n path = \"/#{path}\"\n path.squeeze!('/')\n path.sub!(%r{/+\\Z}, '')\n path = '/' if path == ''\n path\n end",
"def normalize_path(path)\n path = \"/#{path}\"\n path.squeeze!('/')\n path.sub!(%r{/+\\Z}, '')\n path = '/' if path == ''\n path\n end",
"def normalize_path(path)\n normalized = Rex::Text.to_ascii(path).downcase\n normalized.gsub!(/[\\x00]*/, '') #delete padding\n normalized.gsub!(/\\\\x([0-9a-f]{2})/i, '') # delete hex chars\n\n normalized\n end",
"def normalize_path(url); end",
"def normalize_path(url); end",
"def normalize_path(p) # NOTE BOOTSTRAP: was action::base::escape_windows_path\n p.tr(\"\\\\\", \"/\")\n end",
"def normalize_paths(paths)\n paths = [paths] unless paths.is_a?(Array)\n paths.map(&:dup).map do |path|\n raise ArgumentError.new(\"Invalid path: #{path}\") unless valid_path?(path)\n # Strip leading slash from extension path\n path.gsub!(/^\\/(?=\\*.)/, '')\n # Escape some valid special characters\n path.gsub!(/[.+$\"]/) {|s| '\\\\' + s}\n # Replace * wildcards with .* regex fragment\n path.gsub!(/\\*/, '.*')\n \"^#{path}#{END_URL_REGEX}\"\n end\nend",
"def normalize_path(path)\n raise if !path.instance_of?(String)\n\n path = path.strip\n if path.size == 0\n path = \"/\"\n end\n if path[0] != \"/\"\n path = \"/\" + path\n end\n return path\n end",
"def normalized_path(file); end",
"def normalize_path(path)\n path.sub(/^\\//, \"\").gsub(\"%20\", \" \")\n end",
"def normalized_path\n if normalized_scheme == \"urn\"\n # Special-case URI. Normalize the NID component only\n nid, p = path.to_s.split(':', 2)\n return \"#{nid.downcase}:#{p}\"\n end\n\n segments = path.to_s.split('/', -1) # preserve null segments\n\n norm_segs = case\n when authority\n # ipath-abempty\n segments.map {|s| normalize_segment(s, ENCODE_ISEGMENT)}\n when segments[0].nil?\n # ipath-absolute\n res = [nil]\n res << normalize_segment(segments[1], ENCODE_ISEGMENT) if segments.length > 1\n res += segments[2..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 2\n res\n when segments[0].to_s.index(':')\n # ipath-noscheme\n res = []\n res << normalize_segment(segments[0], ENCODE_ISEGMENT_NC)\n res += segments[1..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 1\n res\n when segments[0]\n # ipath-rootless\n # ipath-noscheme\n res = []\n res << normalize_segment(segments[0], ENCODE_ISEGMENT)\n res += segments[1..-1].map {|s| normalize_segment(s, ENCODE_ISEGMENT)} if segments.length > 1\n res\n else\n # Should be empty\n segments\n end\n\n res = self.class.normalize_path(norm_segs.join(\"/\"))\n # Special rules for specific protocols having empty paths\n (res.empty? && %w(http https ftp tftp).include?(normalized_scheme)) ? '/' : res\n end",
"def normalize_uri(*strs)\n new_str = strs * \"/\"\n\n new_str = new_str.gsub!(\"//\", \"/\") while new_str.index(\"//\")\n\n # Makes sure there's a starting slash\n unless new_str[0,1] == '/'\n new_str = '/' + new_str\n end\n\n new_str\n end",
"def cleanpath\n names = []\n split('/').each do |name|\n case name\n when '..'\n names.pop\n when '.'\n when ''\n else\n names.push name\n end\n end\n names.join('/')\n end",
"def sanitize_path\n gsub(/[\\/: ]/,'_')\n end",
"def normalize_path(path)\n return '' if path.eql? '<>'\n path =~ PATH\n $~[1].to_s.downcase + normalize_local_part($~[9]) + \"@\" + $~[12].downcase\n end",
"def relativize_paths(paths)\n return paths unless relativize_paths?\n paths.map do |path|\n path.gsub(%r{^#{@directory}/}, '')\n end\n end",
"def cleanup_paths(*paths)\n #.gsub(%r{#{@locations[:root]}/#{@locations[:root]}}, @locations[:root])\n paths.join('/').gsub(/[\\/]{2,}/,'/')\n end",
"def unify_path(s)\r\n p = s.frozen? ? s.dup : s\r\n p.gsub!( /\\\\/, '/' )\r\n p = \"#{$1.upcase}/#{$POSTMATCH}\" if p =~ REGEX_DISK\r\n if RUBY_PLATFORM =~ REGEX_CYGWIN\r\n\tif p =~ REGEX_CYGDRIVE\r\n\t p = \"/cygdrive/#{$1.upcase}/#{$POSTMATCH}\" \r\n\telse\r\n\t p.sub!( REGEX_DISK2, '/cygdrive/\\1/' ) if @name == 'PATH'\r\n\tend\r\n end\r\n return p\r\n end",
"def normalize_uri(*strs)\n new_str = strs * '/'\n new_str = new_str.gsub!('//', '/') while new_str.index('//')\n new_str\n end",
"def sanitized_path(base_directory, questionable_path); end",
"def sanitized_path(base_directory, questionable_path); end",
"def sanitized_path(base_directory, questionable_path); end",
"def sanitized_path(base_directory, questionable_path); end",
"def sanitized_path(base_directory, questionable_path); end",
"def sanitized_path(base_directory, questionable_path); end",
"def relativize_path(path)\n path.to_s.gsub(/^\\/?#{Regexp.escape(root_path.to_s)}\\/?/, '')\n end",
"def normalize\n uri = dup\n uri.normalize!\n uri\n end",
"def sanitize_path(path)\n newpath = path.gsub(/\\/+/, '/')\n while newpath.gsub!(%r{([^/]+)/\\.\\./?}) { |match|\n $1 == '..' ? match : ''\n } do end\n newpath.gsub(%r{/\\./}, '/').sub(%r{/\\.\\z}, '/')\n end",
"def clean_path(directory)\n directory.gsub(/\\/\\//, '/')\n end",
"def clean_path(path)\n if path\n (path[0] != '/' ? path.insert(0, '/') : path).gsub(/\\/{2,}/, '/')\n end\n end",
"def canonical_path\n p = path.gsub(/\\/+/,'/')\n p.length > 1 ? p.chomp('/') : p\n end",
"def normalize_req_path(req_path)\n # 1) Decode the req_path with URI::decode\n req_path = URI::decode(req_path)\n # 2) Strip first\n req_path = req_path.strip\n # 3) Remove first slash \n req_path = req_path[1..-1] if req_path[0,1]=='/'\n # 4) Remove last slash\n req_path = req_path[0..-2] if req_path[req_path.length-1,1]=='/'\n req_path\n end",
"def normalize_path(path)\n path.scan(/%(\\h\\h)/) do |hex, _|\n path = path.gsub(/%#{hex}/, hex.to_i(16).chr)\n end\n path\nend",
"def remove_leading_slash(path); end",
"def sanitize_path(path); end",
"def normalize!\n if path&.empty?\n set_path('/')\n end\n if scheme && scheme != scheme.downcase\n set_scheme(self.scheme.downcase)\n end\n if host && host != host.downcase\n set_host(self.host.downcase)\n end\n end",
"def unescape_path(path); end",
"def rewrite_base_path(path) # :nodoc:\n if path !~ %r(^/)\n File.join('/', dir, path)\n else\n path\n end\n end",
"def pathify\n whitespace_replacement_token = self.index('_').nil? ? '-' : '_'\n self\n .convert_smart_punctuation\n .convert_accented_html_entities\n .convert_vulgar_fractions\n .convert_unreadable_control_characters\n .convert_miscellaneous_html_entities\n .to_ascii\n .collapse\n .replace_whitespace(whitespace_replacement_token)\n .collapse(whitespace_replacement_token)\n .downcase\n end",
"def sanitizeFilePath(path)\n path = path.gsub(/[^-a-z A-Z0-9_.\\/]/, '_').split(\"/\").map { |part|\n part.sub(/^\\.+/, '_').sub(/\\.+$/, '_')\n }.join('/')\nend",
"def sanitize_path(path)\n # joining (e.g. `foo + \"/\" + bar`)\n path = path.gsub(%r{^/+}, \"/\")\n\n # remove leading and trailing slash\n path.sub(%r{^/}, \"\").sub(%r{/$}, \"\")\n end",
"def generate_rewrite_path(path)\n path.gsub(current_localization.path, self.description.rewrite_route)\n end",
"def normalized_paths\n @paths.map do |path|\n if path =~ events_path\n path.gsub(events_path, '').to_i\n else\n path\n end\n end\n end",
"def sanitized_path(*paths)\n safe_paths = paths.map do | path_name |\n path_name.strip.tap do |name|\n # Finally, replace all non alphanumeric, underscore\n # or periods with underscore\n name.gsub! /[^\\w\\-]/, '_'\n end\n end\n\n File.join(safe_paths)\n end",
"def normalize_url(path)\n @known_pairs ||= {}\n @public_directories_regex ||= Regexp.new(Bones.public_directories.join('|'))\n \n if v = @known_pairs[path]\n return v\n else\n value = case\n when path =~ /^(\\w{3,}:\\/\\/|mailto)/\n # don't do anything to this type of URL\n return path\n when path =~ @public_directories_regex\n path\n when File.directory?('pages' / path)\n path\n else\n # don't add .html if there's already an extension\n path =~ /\\..+/ ? path : path + '.html'\n end\n \n @known_pairs[path] = options.base / value\n end \n end",
"def transform_paths(attrs)\n [:stdout_logfile, :stderr_logfile].each do |key|\n value = attrs.send key\n path = Pathname.new(value)\n next if value.empty? || path.absolute?\n new_value = \"#{attrs.working_dir}/#{path}\"\n attrs.send \"#{key}=\".to_sym, new_value\n end\n end",
"def normalize_path(test, path)\n Pathname.new(path).relative_path_from(test.project.path.realpath).to_s\n end",
"def rto(a, b)\n\tPathname.new(File.join a, '..', b).cleanpath.to_s\nend",
"def convert_path(base: self.class.pwd, mode: :clean, checkdir: false)\n\t\t\t\tcase mode\n\t\t\t\twhen :clean\n\t\t\t\t\tcleanpath\n\t\t\t\twhen :clean_sym\n\t\t\t\t\tcleanpath(consider_symlink: true)\n\t\t\t\twhen :rel\n\t\t\t\t\trel_path(base: base, checkdir: checkdir)\n\t\t\t\twhen :relative\n\t\t\t\t\trel_path(base: base, checkdir: checkdir) unless self.relative?\n\t\t\t\twhen :absolute,:abs\n\t\t\t\t\tabs_path(base: base, mode: :abs)\n\t\t\t\twhen :abs_clean\n\t\t\t\t\tabs_path(base: base, mode: :clean)\n\t\t\t\twhen :abs_cleansym\n\t\t\t\t\tabs_path(base: base, mode: :cleansym)\n\t\t\t\twhen :abs_real\n\t\t\t\t\tabs_path(base: base, mode: :real)\n\t\t\t\twhen :abs_realdir\n\t\t\t\t\tabs_path(base: base, mode: :realdir)\n\t\t\t\telse\n\t\t\t\t\tself\n\t\t\t\tend\n\t\t\tend",
"def fix_path(path)\n path_segments = path.split(\"/\")\n \"/\" + path_segments[1] + \"/act_\" + path_segments[2]\n end",
"def preprocess_path(path, internal_pwd)\n path = '' unless path\n path.strip!\n\n path = unless File.exists? path\n begin\n instance_eval(path)\n rescue NameError, SyntaxError\n end\n end || path\n\n File.expand_path(path)\n end",
"def uri_normalizer; end",
"def convert_path(path)\n return path\n end",
"def normalize(input)\n no_dots = remove_dots(input)\n\n final = []\n while i = no_dots.index('..')\n if i == 0\n final << no_dots.shift\n else\n no_dots.delete_at(i-1)\n no_dots.delete_at(i-1)\n end\n end\n\n (final+no_dots).join('/')\nend",
"def unslashed(path)\n path.sub! /\\/$/, '' if path.end_with? '/'\n return path\n end",
"def cleanpath_aggressive\n path = @path\n names = []\n pre = path\n while r = chop_basename(pre)\n pre, base = r\n case base\n when '.'\n when '..'\n names.unshift base\n else\n if names[0] == '..'\n names.shift\n else\n names.unshift base\n end\n end\n end\n if File.basename(pre).include? '/'\n names.shift while names[0] == '..'\n end\n Path.new(prepend_prefix(pre, File.join(*names)))\n end",
"def normalized_path_name(path, bases)\n normalised_path = normalise_path(path, bases[:directory])\n\n # https://tools.ietf.org/html/rfc3986#section-3\n # paths for resource groups (e.g. directories) should always have a trailing slash\n #2.3.1 :006 > File.join(\"/a/\",\"/b\", \"/\") => \"/a/b/\"\n #2.3.1 :007 > File.join(\"/a/\",\"/b/\", \"/\") => \"/a/b/\"\n #2.3.1 :008 > File.join(\"/a\", \"b\", \"/\") => \"/a/b/\"\n normalized_url_path = File.join(bases[:url_base_path], normalised_path, '/')\n\n # we use the normalized_url_path so that the name fragment always has a value that makes sense\n normalised_name = normalised_name(normalized_url_path)\n\n { path: normalized_url_path, name: normalised_name }\n end",
"def prepare(path)\n path.delete_prefix('/').gsub(%r{//}, '/').gsub(%r{/+\\z}, '')\n end",
"def unnormalize_path(p)\n p[1] == 58 ? p[2, p.size] : p\n end",
"def sanitize_path(path)\n # joining (e.g. `foo + \"/\" + bar`)\n path = path.gsub(/^\\/+/, '/')\n\n # remove leading and trailing slash\n return path.sub(/^\\//, '').sub(/\\/$/, '')\n end",
"def ns_pathify\n to_s.gsub('__', '/')\n end",
"def scrub_path(p)\n np = \"\"\n for i in 0..(p.size-1)\n c = p[i]\n if c == '/'\n c = '\\\\'\n end\n np += c\n end\n np\nend",
"def simplify_path(path)\n path_tokens = path.split(\"/\").reject{ |x| x.empty? || x == \".\" }\n stack = []\n path_tokens.each{ |x|\n if x == \"..\"\n stack.pop if stack.any?\n else\n stack.push(x)\n end\n }\n\n \"/\" << stack.join(\"/\")\nend",
"def rewrite_path # :nodoc:\n if uri.path[0] != ?/\n prepend_path File.join('/', options[:dir].to_s)\n end\n end",
"def join_paths(paths)\n paths.join('/').gsub(%r{/+}, '/')\n end",
"def cleanpath_aggressive\n # cleanpath_aggressive assumes:\n # * no symlink\n # * all pathname prefix contained in the pathname is existing directory\n return Path::Name.create([],@absolute,@trail) if path.empty?\n absolute = absolute?\n trail = trail?\n names = []\n @path.each {|name|\n next if name == '.'\n if name == '..'\n if names.empty?\n next if absolute\n else\n if names.last != '..'\n names.pop\n next\n end\n end\n end\n names << name\n }\n return Path::Name.new(absolute ? '/' : '.') if names.empty?\n #path = []\n #path << '' if absolute\n #path.concat(names)\n Path::Name.create(names, absolute) #, trail)\n end",
"def uniPath(source)\n source.gsub(/\\\\/, File::SEPARATOR)\nend",
"def clean_path(path)\n\t\t\tif @posix_support\n\t\t\t\treturn path\n\t\t\telse\n\t\t\t\treturn path.gsub(/\\//,'\\\\')\n\t\t\tend\n\t\tend",
"def canonicalize\n FilePath.new(File.expand_path(to_s))\n end",
"def convert_path_relation(relation)\n relation.map{|r| \"<\" + Xplain::Namespace.expand_uri(r.id) + \">\"}.join(\"/\")\n end",
"def normalised_name(path)\n path == '/' ? '/' : File.basename(path)\n end",
"def fix_path(path)\n path_parts = path.split('/')\n return path_parts.join(File::SEPARATOR)\n end",
"def fix_path(path)\n path_parts = path.split('/')\n return path_parts.join(File::SEPARATOR)\n end",
"def rootify_path path\n path = normalize_path(path, true)\n path.size > 0 ? '/%s/' % path : '/'\n end",
"def normalize_path(api_path, resource_id)\n return api_path unless resource_id\n\n format(api_path, resource_id: resource_id)\n end",
"def sanitized_path(base_directory, questionable_path)\n return base_directory if base_directory.eql?(questionable_path)\n\n clean_path = File.expand_path(questionable_path, \"/\")\n clean_path = clean_path.sub(/\\A\\w\\:\\//, '/')\n\n if clean_path.start_with?(base_directory.sub(/\\A\\w\\:\\//, '/'))\n clean_path\n else\n File.join(base_directory, clean_path)\n end\n end",
"def normalized_request_path(path)\n if path == \"/\"\n path\n else\n path.chomp(\"/\")\n end\n end",
"def convert_path(string, direction)\n string = string.dup\n if direction == :decode\n ENCODINGS.each { |k, v| string.gsub!(v.to_s, k.to_s) }\n elsif direction == :encode\n ENCODINGS.each { |k, v| string.gsub!(k.to_s, v.to_s) }\n else\n raise ArgumentError, \"direction is required\"\n end\n string\n end",
"def normalize_path(name, prefix)\n prefix.present? ? \"#{prefix}/#{name}\" : name\n end",
"def normalize_path(name, prefix)\n prefix.present? ? \"#{prefix}/#{name}\" : name\n end",
"def cleanpath\n path = @path\n names = []\n pre = path\n while r = chop_basename(pre)\n pre, base = r\n case base\n when '.'\n when '..'\n names.unshift base\n else\n if names[0] == '..'\n names.shift\n else\n names.unshift base\n end\n end\n end\n if /#{SEPARATOR_PAT}/o =~ File.basename(pre)\n names.shift while names[0] == '..'\n end\n self.class.new(prepend_prefix(pre, File.join(*names)))\n end",
"def clean_path(path)\n path.sub(/^\\//,'')\n end",
"def sanitize_path(path)\n path.gsub(/\\.\\.(?=$|\\/)/, '') unless path.nil?\n end",
"def format_path(entry)\n server_path = entry.path\n if base_path && server_path[0,base_path.length] == base_path\n if server_path == base_path\n return \".\"\n elsif server_path[base_path.length,1] == \"/\"\n return server_path[base_path.length + 1, server_path.length - base_path.length - 1]\n elsif base_path == \"/\" && server_path[0,1] == \"/\"\n return server_path[1, server_path.length - 1]\n end\n end\n server_path\n end",
"def safe_path(path)\n path.gsub(\"/\", \"^^\")\n end",
"def simplify_path(path)\n return '' if path.empty?\n\n start_with_slash = path[0] == '/'\n stack = []\n stack << '' if start_with_slash\n tokens = path.split('/')\n tokens.each do |token|\n case token\n when '..'\n stack.pop if stack[-1] != ''\n\n when '.', ''\n next\n else\n stack.push token\n end\n end\n\n return '/' if stack.length == 1 && stack[0] == ''\n\n stack.join('/')\nend",
"def normalize_url(url)\n\t\tbegin\n\t\t\turl.strip!\n\t\t\t# Converting the scheme and host to lower case in the process, i.e. 'HTTP://www.Example.com/' => 'http://www.example.com/' \n\t\t\t# Normalize the base\n\t\t\tbase=url_2_site(url) \n\t\t\t# Case#1, remove the trailing dot after the hostname, i.e, 'http://www.yahoo.com./' => 'http://www.yahoo.com/'\n\t\t\tbase=base.sub(/\\.\\/$/,'/')\n\t\t\t# Normalize the relative path, case#1\n\t\t\t# retrieve the file path and remove the first '/' or '.', \n\t\t\t# i.e. 'http://www.example.com/mypath' or 'http://www.example.com/./mypath' => 'mypath'\n\t\t\tpath=url_2_path(url).sub(/^(\\/|\\.)*/,'')\n\t\t\t# Normalize the relative path, case#2\n\t\t\t# Replace dot-segments. \"/../\" and \"/./\" with \"/\", i.e. 'http://www.example.com/../a/b/../c/./d.html\" => 'http://www.example.com/a/c/d.html'\n\t\t\tpath=path.gsub(/\\/\\.{1,2}\\//,'/')\n\t\t\tif path.nil?\n\t\t\t\treturn base\n\t\t\telse\n\t\t\t\treturn base+path\n\t\t\tend\n\t\trescue => ee\n\t\t\tputs \"Exception on method #{__method__} for #{url}: #{ee}\" if @verbose\n\t\t\treturn url\n\t\tend\n\tend",
"def reduce_path(path)\n if path =~ /^(https?:\\/\\/.+)(\\/.*)/\n prefix = $1\n path = $2\n relative = false\n else\n prefix = nil\n relative = path[0] != '/'\n end\n\n while path.sub!(/\\/*[^\\/]+\\/+\\.\\./, ''); end\n while path.sub!(/\\/+\\.\\/+/, '/'); end\n path = path[2..-1] if path[0..1] == './'\n while path.sub!(/\\/\\//, '/'); end\n\n path = path[1..-1] if relative and path[0] == '/'\n path = prefix + path if prefix\n path\n end",
"def sanitize_path(path, options = {})\n # remove the leading \"/\", we'll add it back after encoding\n path = path.slice(1, path.length) if Regexp.new('^/') =~ path\n if options[:disable_path_encoding]\n return \"/\" + path\n # if path is being used as a proxy, encode the entire thing\n elsif /^https?/ =~ path\n return encode_URI_Component(path)\n else\n # otherwise, encode only specific characters\n return encode_URI(path)\n end\n end",
"def field_path_transform(s_share,s_path)\n src_path = @fields[s_path]\n return if src_path.nil? || src_path.empty?\n notify \"Spliting Path:#{s_path} to #{s_share}\"\n result = path_transform(@fields[s_path])\n return if result.values.any?{|val| val.nil?}\n @fields[s_path] = result[:path]\n @fields[s_share] = result[:share]\n patch_url_from_field([s_share,s_path])\n end",
"def join_path(path)\n if path.include?('\\\\') && path.include?('/')\n path.gsub('\\\\', '/')\n else\n path\n end\n end",
"def customize_path(first, last)\n #return (first.gsub(/[.!@%&\"]/,'').squeeze(\" \").tr(\" \",'+')+ '_'+last.gsub(/[.!@%&\"]/,' ').squeeze(\" \").tr(\" \",'+')).split('+').map(&:capitalize)*'+'\n return (first.gsub(/[.!@%&\"]/,'').squeeze(\" \").tr(\" \",'+').split('+').map(&:capitalize)*'+' + '_'+last.gsub(/[.!@%&\"]/,' ').squeeze(\" \").tr(\" \",'+').split('+').map(&:capitalize)*'+')\n end",
"def convert_slashes(path)\n path.gsub('/', '\\\\').gsub('\\\\', '\\\\\\\\\\\\\\\\') #eek\n end",
"def normalize_uri\r\n self.link = Addressable::URI.heuristic_parse(self.link).normalize!.to_s if self.link\r\n end",
"def reconstruct_path(came_from, current)\n while came_from.include?(current)\n current = came_from[current]\n current.path!\n end\n @start.start!\n @end.end!\n end"
] |
[
"0.81686854",
"0.81686854",
"0.73655075",
"0.7336732",
"0.73290545",
"0.73013103",
"0.7231049",
"0.72004396",
"0.70407486",
"0.70407486",
"0.6906958",
"0.68598604",
"0.6854583",
"0.6842715",
"0.67916447",
"0.66807663",
"0.66719455",
"0.66707265",
"0.6633365",
"0.6625123",
"0.66094166",
"0.6598202",
"0.65276885",
"0.65168434",
"0.6490464",
"0.6490464",
"0.6490464",
"0.6490464",
"0.6490464",
"0.6490464",
"0.64851266",
"0.64312303",
"0.64303213",
"0.64141625",
"0.638328",
"0.6370365",
"0.63535315",
"0.63473314",
"0.63410467",
"0.6337497",
"0.6336248",
"0.6297353",
"0.6286144",
"0.62833077",
"0.627464",
"0.6267192",
"0.62578404",
"0.6251259",
"0.6250043",
"0.6232016",
"0.62272507",
"0.62256515",
"0.6221616",
"0.6219723",
"0.6216834",
"0.6201009",
"0.6200389",
"0.6194779",
"0.61934674",
"0.6185838",
"0.6184297",
"0.6172172",
"0.6170637",
"0.6167952",
"0.6167188",
"0.61670804",
"0.6164691",
"0.6137824",
"0.61312324",
"0.61267054",
"0.61260384",
"0.60999393",
"0.60956734",
"0.6087916",
"0.6081745",
"0.60729975",
"0.60717237",
"0.60717237",
"0.6064717",
"0.60604817",
"0.6052585",
"0.60521406",
"0.60474735",
"0.6047166",
"0.60442996",
"0.60440826",
"0.60421956",
"0.60317314",
"0.60209167",
"0.60188174",
"0.59906614",
"0.5986728",
"0.5970967",
"0.5966698",
"0.59413016",
"0.5937619",
"0.592972",
"0.592331",
"0.59226006",
"0.5921926"
] |
0.6495284
|
24
|
Convert all fonts to ems
|
def convert_fonts
out = ""
sass.each_line do |line|
line.gsub!(/(\s*)(word-spacing|letter-spacing|font-size|line-height|margin-[^\s]+|margin|padding-[\s]+|padding)\s*:(.*)/) do |m|
# indent rule: value
m = "#{$1}#{$2}: #{CSS.val_to_em($3)}"
end
out << line
end
self.sass = out
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def convert_fonts(sass)\n out = \"\"\n sass.each_line do |line|\n line.gsub!(/(\\s*)(word-spacing|letter-spacing|font-size|line-height|margin-[^\\s]+|margin|padding-[\\s]+|padding)\\s*:(.*)/) do |m|\n # :spacing :rule :value\n m = \"%s%s: %s\" % [$1, $2, CSS.val_to_em($3)]\n end\n out << line\n end\n out\n end",
"def convert_em(el, opts)\n el_classes = el.get_classes\n formatting_attrs = []\n if el_classes.empty?\n formatting_attrs = [:italic]\n else\n el_classes.each { |el_class|\n case el_class\n when 'bold'\n formatting_attrs << :bold\n when 'italic'\n formatting_attrs << :italic\n when 'line_break'\n # ignore\n when 'pn'\n # ignore\n when 'smcaps'\n formatting_attrs << :smcaps\n when 'subscript'\n formatting_attrs << :subscript\n when 'superscript'\n formatting_attrs << :superscript\n when 'underline'\n formatting_attrs << :underline\n else\n raise \"Handle this: #{ el.element_summary }\"\n end\n }\n end\n @current_block[:formatting_spans] |= formatting_attrs\n inner(el, opts)\n ''\n end",
"def set_fonts\n font_families.update(\"Arial\" => {\n :normal => \"#{Rails.root}/vendor/assets/fonts/Arial.ttf\",\n :bold => \"#{Rails.root}/vendor/assets/fonts/Arial-Bold.ttf\"\n })\n font \"Arial\"\n end",
"def convert_em(el)\r\n results = []\r\n el.children.each do |inner_el|\r\n results << inner_el.value\r\n end\r\n t = results.size > 1 ? results.join : results[0]\r\n %[para \"#{t}\", :emphasis => \"italic\"] \r\n end",
"def semanticize_font_styles!\n @document.tree.css('span').each do |node|\n if node.bold?\n node.node_name = 'strong'\n elsif node.italic?\n node.node_name = 'em'\n end\n end\n end",
"def explode_fonts\n puts 'Explode fonts...'.yellow\n FileUtils.rm_rf(@glyphs)\n FileUtils.mkdir_p(@glyphs)\n Dir.chdir(@sources) do\n for font_fullname in Dir['*'].sort\n font_dir = @sources.join(font_fullname)\n font_name = font_fullname.split('-')[1..-1].join('-')\n font_file = font_dir.join('font.svg')\n config_file = font_dir.join('config.yml')\n if font_file.exist? && config_file.exist?\n command(\"node_modules/.bin/svg-font-dump -n -c #{config_file} -f -i #{font_file} -o #{@glyphs}\")\n end\n end\n end\n # Removes weird icons\n Dir.chdir(@glyphs) do\n Dir.glob('{*,.*}').sort.collect do |cf|\n next if cf.to_s =~ /\\A[a-z0-9]+(\\-[a-z0-9]+)*\\.svg\\z/\n next if ['..', '.'].include? cf\n puts ' - ' + \"Remove #{cf}\".red\n FileUtils.rm_f(cf)\n end\n end\n end",
"def set_fonts\n font_families.update Elegant.configuration.fonts\n fallback_fonts ['Fallback']\n end",
"def set_font\n font_families.update(\n 'HealthQuestPDF' => {\n normal: HealthQuest::Engine.root.join('lib', 'fonts', 'sourcesanspro-regular-webfont.ttf'),\n medium: HealthQuest::Engine.root.join('lib', 'fonts', 'sourcesanspro-bold-webfont.ttf'),\n bold: HealthQuest::Engine.root.join('lib', 'fonts', 'bitter-bold.ttf')\n }\n )\n font 'HealthQuestPDF'\n end",
"def normalize_font(source, destination, options = {})\n hexa = options[:hexa] || {}\n interm = source.dirname.join(source.basename('.*').to_s + '.svg')\n if interm.exist?\n puts \"No conversion needed for #{interm}\".white\n else\n command(\"fontforge -quiet -script #{@convert_script} #{source} svg\")\n end\n i = File.open(interm)\n doc = Nokogiri::XML(i) do |config|\n config.nonet.strict.noblanks\n end\n i.close\n doc.root.xpath('//svg:glyph[@d]', SVG_NAMESPACES).each do |glyph|\n name = glyph.attr('glyph-name')\n unicode = glyph.attr('unicode').to_s\n if unicode[0]\n hex = '%4.4x' % unicode[0].ord\n name = hexa[hex] if hexa[hex]\n end\n if name && name =~ /^[a-z0-9]+((\\_|\\-)[a-z0-9]+)*$/\n glyph['glyph-name'] = name.gsub(/[^a-z0-9]+/, '-')\n else\n puts \" - weird name (#{unicode.inspect}): #{name.inspect.red} \"\n end\n end\n doc.root.default_namespace = SVG_NAMESPACES[:svg]\n for name, url in SVG_NAMESPACES\n doc.root.add_namespace(name.to_s, url)\n end\n File.open(destination, 'wb') do |f|\n f.write doc.to_s\n end\n end",
"def font_sizes\n @font_sizes ||= begin\n sizes = []\n doc.css(\"[style]\").each do |element|\n sizes.push element.font_size.round(-1) unless element.font_size.nil?\n end\n sizes.uniq.sort\n end\n end",
"def change_tags_to_em(doc, good_rules)\n bold_rule = good_rules.find{|r| r.tag == :bold}\n em_rule = good_rules.find{|r| r.tag == :em}\n underline_rule = good_rules.find{|r| r.tag == :underline}\n\n good_rules.each do |rule|\n\n doc.css(*rule.selectors).each do |node|\n node_class = node[:class]\n next if node.name == 'body'\n next if !node_class\n node_classes = node_class.split(' ').map {|css_class| \".#{css_class}\"}\n difference = node_classes - rule.selectors\n if difference.empty? || # none of the classes are different - 1:1 case\n good_rules.none?{|good_rule| difference.any?{|d| good_rule.selectors.include?(d)} }\n if rule.tag == :em\n node.replace doc.create_element('em', node.inner_html)\n end\n if rule.tag == :bold\n node.replace doc.create_element('em', node.inner_html, :class => 'strong')\n end\n if rule.tag == :underline\n node.replace doc.create_element('em', node.inner_html, :class => 'underline')\n end\n if rule.tag == :epigraph\n node.replace doc.create_element('p', node.inner_html, :class => 'app_epigraph')\n end\n\n else # we have something, this must be a n:2 case\n #is it em class strong?\n if (difference - (bold_rule.selectors + em_rule.selectors)).empty?\n node.replace doc.create_element('em', node.inner_html, :class => 'strong')\n next\n end\n\n if (difference - (underline_rule.selectors + em_rule.selectors)).empty?\n node.replace doc.create_element('em', node.inner_html, :class => 'underline')\n end\n end\n end\n end\n end",
"def type1_font_names\n if @options[:built_in_fonts]\n PdfK::FONT_NAMES\n else\n AFM::font_names\n end\n end",
"def convert_font_args(params)\n return unless params\n font = {\n :_name => params[:name],\n :_color => params[:color],\n :_size => params[:size],\n :_bold => params[:bold],\n :_italic => params[:italic],\n :_underline => params[:underline],\n :_pitch_family => params[:pitch_family],\n :_charset => params[:charset],\n :_baseline => params[:baseline] || 0\n }\n\n # Convert font size units.\n font[:_size] *= 100 if font[:_size] && font[:_size] != 0\n\n font\n end",
"def settextfontprec(*)\n super\n end",
"def compute_text_run_attrs_from_em(em_classes)\n # Handle em with no classes: results in plain italics\n return { italic: true } if em_classes.empty?\n r = {}\n r[:bold] = true if em_classes.include?('bold')\n r[:italic] = true if em_classes.include?('italic')\n r[:small_caps] = true if em_classes.include?('smcaps')\n r[:underline] = true if em_classes.include?('underline')\n r[:vert_align] = 'subscript' if em_classes.include?('subscript')\n r[:vert_align] = 'superscript' if em_classes.include?('superscript')\n r\n end",
"def prepare_fonts # :nodoc:\n fonts = {}\n\n @xf_formats.each { |format| format.set_font_info(fonts) }\n\n @font_count = fonts.size\n\n # For the DXF formats we only need to check if the properties have changed.\n @dxf_formats.each do |format|\n # The only font properties that can change for a DXF format are: color,\n # bold, italic, underline and strikethrough.\n format.has_dxf_font(true) if format.color? || format.bold? || format.italic? || format.underline? || format.strikeout?\n end\n end",
"def font_descender(size = nil)\n size = @font_size if size.nil? or size <= 0\n\n select_font(\"Helvetica\") if @fonts.empty?\n hi = @fonts[@current_font].fontbbox[1].to_f\n (size * hi / 1000.0)\n end",
"def test05()\n theUserInterfaceFonts = \"kCTFontUIFontMiniEmphasizedSystem kCTFontUIFontSmallToolbar kCTFontUIFontWindowTitle kCTFontUIFontMenuTitle kCTFontUIFontSystem kCTFontUIFontMenuItem kCTFontUIFontEmphasizedSystem kCTFontUIFontToolbar kCTFontUIFontMessage kCTFontUIFontEmphasizedSystemDetail kCTFontUIFontSmallEmphasizedSystem kCTFontUIFontUserFixedPitch kCTFontUIFontMiniSystem kCTFontUIFontLabel kCTFontUIFontControlContent kCTFontUIFontSystemDetail kCTFontUIFontViews kCTFontUIFontUser kCTFontUIFontSmallSystem kCTFontUIFontApplication kCTFontUIFontToolTip\"\n begin\n result = MIMeta.listuserinterfacefonts\n unless result.eql? theUserInterfaceFonts\n puts \"User interface fonts different: #{result}\"\n end\n\n rescue RuntimeError => e\n $errorcode = Smig.exitvalue\n unless $errorcode.zero?\n puts \"Exit string: \" + Smig.exitstring\n puts $teststring + \" Exit status: \" + $errorcode.to_s\n end\n puts e.message\n puts e.backtrace.to_s\n end\nend",
"def pbNarrowFontName\n return MessageConfig.pbTryFonts(\"Power Green Narrow With BLD\",\"Pokemon Emerald Narrow With BLD\",\n \"Arial Narrow\",\"Arial\")\nend",
"def font_setup\n %Q(font \"#{@font},#{@fontsize}\")\n end",
"def quoted_fonts\n quoted_fonts = @font_family.map do |font|\n if font.include?(' ') && font[0] != \"'\"\n \"'#{font}'\"\n else\n font\n end\n end\n\n quoted_fonts.join(', ')\n end",
"def monospace_fonts\n @monospace_fonts ||= FONTS.select do |name|\n re = Regexp.new(name.gsub(' ', ' ?'), 'i')\n available_fonts.grep(re).any?\n end\n end",
"def maiil_reset_font\n fn = MA_IconItemList::NUM_FONTNAME ? MA_IconItemList::NUM_FONTNAME : Font.default_name\n contents.font = Font.new(fn, MA_IconItemList::NUM_FONTSIZE) # name and size\n contents.font.bold = MA_IconItemList::NUM_BOLD # Set Bold\n contents.font.italic = MA_IconItemList::NUM_ITALIC # Set Italic\n contents.font.shadow = MA_IconItemList::NUM_SHADOW # Set Shadow\n contents.font.outline = MA_IconItemList::NUM_OUTLINE # Set outline\n oc = MA_IconItemList::NUM_OUT_COLOUR ? MA_IconItemList::NUM_OUT_COLOUR : Font.default_out_color\n contents.font.out_color = text_color(oc) # outline color\n end",
"def time_to_font(time,font)\n output = []\n for i in 0...time.length()\n converted_font = convert_1_number_to_1_font(time[i],font)\n output.append(converted_font)\n end\n return output\nend",
"def interpret(ps)\n raise Error unless ps.fonts.has_key?(@index)\n ps.font = ps.fonts[@index]\n end",
"def load_fonts\n\n # Load fonts.\n self.load_single_font('Across The Road')\n self.load_single_font('Alabama')\n self.load_single_font('Arial')\n self.load_single_font('Arial Narrow')\n self.load_single_font('Arty Signature')\n self.load_single_font('Asem Kandis')\n self.load_single_font('Autograf')\n self.load_single_font('Born Ready')\n self.load_single_font('Brittany Signature')\n self.load_single_font('Bulgatti')\n self.load_single_font('Courier New')\n self.load_single_font('Estelly')\n self.load_single_font('Friday Vibes')\n self.load_single_font('From Skyler')\n self.load_single_font('Gallatone')\n self.load_single_font('Halimun')\n self.load_single_font('Hello Santtiny')\n self.load_single_font('Just Realize')\n self.load_single_font('Just Signature')\n self.load_single_font('Mayestica')\n self.load_single_font('Menlo')\n self.load_single_font('Notera')\n self.load_single_font('Prestige Signature')\n self.load_single_font('Reinata')\n self.load_single_font('Santos Dumont')\n self.load_single_font('SF Mono')\n self.load_single_font('Shopping List')\n self.load_single_font('Signatures')\n self.load_single_font('Signerica')\n self.load_single_font('Silver Pen')\n self.load_single_font('Sophistica')\n self.load_single_font('Source Code Pro')\n self.load_single_font('Southampton')\n self.load_single_font('Thankfully')\n self.load_single_font('The Jacklyn')\n self.load_single_font('Tomatoes')\n self.load_single_font('Wanted Signature')\n self.load_single_font('White Angelica')\n self.load_single_font('Whitney')\n self.load_single_font('Whitney Bold')\n self.load_single_font('Whitney Index Rounded')\n self.load_single_font('Whitney Index Squared')\n self.load_single_font('Xtreem')\n self.load_single_font('Gotham Condensed')\n\n end",
"def set_font_sizes(font_sizes:)\n {\n method: \"Page.setFontSizes\",\n params: { fontSizes: font_sizes }.compact\n }\n end",
"def init_font_families\n # Set the known family groups. These font families will be used to\n # enable bold and italic markers to be included within text\n # streams. HTML forms will be used... <b></b> <i></i>\n @font_families[\"Helvetica\"] =\n {\n \"b\" => 'Helvetica-Bold',\n \"i\" => 'Helvetica-Oblique',\n \"bi\" => 'Helvetica-BoldOblique',\n \"ib\" => 'Helvetica-BoldOblique'\n }\n @font_families['Courier'] =\n {\n \"b\" => 'Courier-Bold',\n \"i\" => 'Courier-Oblique',\n \"bi\" => 'Courier-BoldOblique',\n \"ib\" => 'Courier-BoldOblique'\n }\n @font_families['Times-Roman'] =\n {\n \"b\" => 'Times-Bold',\n \"i\" => 'Times-Italic',\n \"bi\" => 'Times-BoldItalic',\n \"ib\" => 'Times-BoldItalic'\n }\n end",
"def load_font(family, height)\n end",
"def preload_font_sizes *sizes\n sizes.flatten.each do |size|\n Helpers::Error.error(\n \"Expected size to be an Integer, but got\",\n \"`#{size.inspect}:#{size.class.name}'.\"\n ) unless (size.is_a? Integer)\n @font_cache[size] ||= Gosu::Font.new(\n size,\n name: @settings.get(:font_name)\n )\n end\n end",
"def font_size\n @font_size ||= [cell_height, cell_width].sort.shift * 0.8\n end",
"def pbSmallFontName\n return MessageConfig.pbTryFonts(\"Power Green Small With BLD\",\"Pokemon Emerald Small With BLD\",\n \"Arial Narrow\",\"Arial\")\nend",
"def initialize_fonts(application)\r\n\t[12, 14, 16, 18, 24].each() do |size|\r\n\t\tFONT[\"Courier #{size}\"] = FXFont.new(application, 'Courier New', size)\r\n\t\tFONT[\"Helvetica #{size}\"] = FXFont.new(application, 'Helvetica', size)\r\n\tend\r\n\t\r\n\tFONT['Courier 24 bold'] = FXFont.new(application, 'Courier New', 24, FXFont::Bold)\r\nend",
"def set_font_path()\n Dir.entries(@output_styles).each do |filename|\n next if filename =~ /^\\.\\.?$/\n filepath = \"#{@output_styles}/#{filename}\"\n\n text = File.read(filepath)\n new_text = text.gsub(/..\\/font/, \"#{@fonts_path}\")\n File.write(filepath, new_text)\n end\n end",
"def _font_family(id)\n {\n 0x00 => :'Not applicable',\n 0x01 => :Roman,\n 0x02 => :Swiss,\n 0x03 => :Modern,\n 0x04 => :Script,\n 0x05 => :Decorative\n }[id]\n end",
"def load_fonts\n @@fonts[\"game\"] = Gosu::Font.new(80)\n @@fonts[\"menu\"] = Gosu::Font.new(40)\n @@fonts[\"notification\"] = Gosu::Font.new(25)\n @@fonts[\"big\"] = Gosu::Font.new(20)\n @@fonts[\"small\"] = Gosu::Font.new(14)\n @@fonts[\"button\"] = Gosu::Font.new(15)\n end",
"def convert_em(el, opts)\n if el.has_class?('pn')\n # extract paragraph number\n text_node = el.children.detect { |e| :text == el.type }\n @current_block.paragraph_number = text_node.value if text_node\n end\n super\n end",
"def small_font\n [-2, 0, 0, 0, 0, 255]\n end",
"def font_encoding(encoding=nil)\n cur_page.font_encoding(encoding)\n end",
"def analyze_glyphs_for_fallback_font_support fragment_hash\n fragment_font = fragment_hash[:font] || (original_font = @document.font.family)\n if (fragment_font_styles = fragment_hash[:styles])\n if fragment_font_styles.include? :bold\n fragment_font_opts = { style: (fragment_font_styles.include? :italic) ? :bold_italic : :bold }\n elsif fragment_font_styles.include? :italic\n fragment_font_opts = { style: :italic }\n end\n end\n fallback_fonts = @fallback_fonts.drop 0\n font_glyph_pairs = []\n @document.save_font do\n fragment_hash[:text].each_char do |char|\n font_glyph_pairs << [(find_font_for_this_glyph char, fragment_font, fragment_font_opts || {}, (fallback_fonts.drop 0)), char]\n end\n end\n # NOTE: don't add a :font to fragment if it wasn't there originally\n font_glyph_pairs.each {|pair| pair[0] = nil if pair[0] == original_font } if original_font\n form_fragments_from_like_font_glyph_pairs font_glyph_pairs, fragment_hash\n end",
"def fontReport(psdFiles)\n fontData = Array.new\n\n psdFiles.each do |psdFile|\n name = File.basename(psdFile)\n PSD.open(psdFile) do |psd|\n puts \"\\n[ #{name} ] Font used =================================== \\n\\n\"\n psd.layers.each do |layer|\n fontRaw = layer.text\n fontString = fontRaw.to_s()\n fontstring = fontString.gsub!(':font=>{:name=>\"', \"spliter\")\n fontstring = fontString.gsub!('\", :sizes=>[', \"spliter\")\n fontArray = fontString.split(\"spliter\")\n fontName = fontArray[1].to_s()\n if fontName == \"\"\n else\n fontData.push(\"* \" + fontName)\n end\n end\n end\n fontDataClean = fontData.uniq\n fontDataClean.each do |d|\n puts d\n end\n end\nend",
"def pbSetSystemFont(bitmap)\n fontname=MessageConfig.pbGetSystemFontName\n bitmap.font.name=fontname\n if fontname==\"Pokemon FireLeaf With BLD\" || fontname==\"Power Red and Green With BLD\"\n bitmap.font.size=29\n elsif fontname==\"Pokemon Emerald Small With BLD\" || fontname==\"Power Green Small With BLD\"\n bitmap.font.size=25\n else\n bitmap.font.size=31\n end\nend",
"def fonts\n package 'ttf-freefarsi', :ensure => :installed\n package 'ttf-farsiweb', :ensure => :installed\n end",
"def font_setup\n font_families.update(\"Montserrat\" => {\n :normal => \"vendor/assets/fonts/Montserrat/Montserrat-Regular.ttf\",\n :italic => \"vendor/assets/fonts/Montserrat/Montserrat-Italic.ttf\",\n :bold => \"vendor/assets/fonts/Montserrat/Montserrat-Bold.ttf\",\n })\n font \"Montserrat\"\n end",
"def fonts(workbook, _center, heading, _colors)\n worksheet = workbook.add_worksheet('Fonts')\n\n worksheet.set_column(0, 0, 30)\n worksheet.set_column(1, 1, 10)\n\n worksheet.write(0, 0, \"Font name\", heading)\n worksheet.write(0, 1, \"Font size\", heading)\n\n fonts = []\n fonts << [10, 'Arial']\n fonts << [12, 'Arial']\n fonts << [14, 'Arial']\n fonts << [12, 'Arial Black']\n fonts << [12, 'Arial Narrow']\n fonts << [12, 'Century Schoolbook']\n fonts << [12, 'Courier']\n fonts << [12, 'Courier New']\n fonts << [12, 'Garamond']\n fonts << [12, 'Impact']\n fonts << [12, 'Lucida Handwriting']\n fonts << [12, 'Times New Roman']\n fonts << [12, 'Symbol']\n fonts << [12, 'Wingdings']\n fonts << [12, 'A font that doesn\\'t exist']\n\n i = 0\n fonts.each do |font|\n format = workbook.add_format\n\n format.set_size(font[0])\n format.set_font(font[1])\n\n i += 1\n worksheet.write(i, 0, font[1], format)\n worksheet.write(i, 1, font[0], format)\n end\n end",
"def inch_to_feet_converter\n\t \n\t end",
"def process_text_options(options)\n if options[:style]\n raise 'Bad font family' unless font.family\n font(font.family, style: options[:style])\n end\n\n # must compare against false to keep kerning on as default\n unless options[:kerning] == false\n options[:kerning] = font.has_kerning_data?\n end\n\n options[:size] ||= font_size\n end",
"def parse_font_options(options = {})\n return if (options.keys & [:fg_color, :sz, :b, :i, :u, :strike, :outline, :shadow, :charset, :family, :font_name]).empty?\n\n Axlsx.instance_values_for(fonts.first).each do |key, value|\n # Thanks for that 1.8.7 - cant do a simple merge...\n options[key.to_sym] = value unless options.key?(key.to_sym)\n end\n font = Font.new(options)\n font.color = Color.new(rgb: options[:fg_color]) if options[:fg_color]\n font.name = options[:font_name] if options[:font_name]\n options[:type] == :dxf ? font : fonts << font\n end",
"def fonts_list\n initiate_library\n FONTS_LIBRARY.keys\n end",
"def font_for(filename,size=16)\n tuple = [filename, size]\n if @fonts.has_key?(tuple)\n return @fonts[tuple]\n else\n fullpath = path_for(filename)\n return nil unless fullpath\n ext = File.extname(filename)\n result = nil\n case(ext.downcase)\n when \".ttf\"\n result = Rubygame::TTF.new(fullpath,size)\n when \".png\"\n result = Rubygame::SFont.new(fullpath)\n end\n @fonts[tuple] = result\n end\n return result\n end",
"def font_size\n size_tag = @styles.xpath('//w:docDefaults//w:rPrDefault//w:rPr//w:sz').first\n size_tag ? size_tag.attributes['val'].value.to_i / 2 : nil\n end",
"def reset_font_settings(*args, &block)\n super(*args, &block)\n set_data_font(@maqj_font_data_type) if @maqj_font_data_type\n end",
"def keyframe_font_sizes(scroll_offset = 0)\n data = { }\n\n initial_pos = calculate_scroll_position(:initial, scroll_offset)\n target_start_pos = calculate_scroll_position(:target_start, scroll_offset)\n target_end_pos = calculate_scroll_position(:target_end, scroll_offset)\n final_pos = calculate_scroll_position(:final, scroll_offset)\n\n data[\"data-#{initial_pos}\"] = \" font-size: #{ @layer.font_size * @layer.start_state_keyframe.scale }em;\"\n data[\"data-#{target_start_pos}\"] = \" font-size: #{ @layer.font_size * @layer.target_state_keyframe.scale }em;\"\n data[\"data-#{target_end_pos}\"] = \" font-size: #{ @layer.font_size * @layer.target_state_keyframe.scale }em;\"\n data[\"data-#{final_pos}\"] = \" font-size: #{ @layer.font_size * @layer.end_state_keyframe.scale }em;\"\n\n data\n end",
"def turn_on_fontmanagement\n mods = ModuleManager.new(@browser)\n Log.logger.info(\"Making sure 'font management' module is enabled.\")\n mods.enable_disable_modules([\"Font management\"], \"on\")\n end",
"def font_size()\n validate_worksheet\n return @workbook.fonts[font_id()][:font][:sz][:attributes][:val]\n end",
"def font(row, col, sheet = nil)\n sheet ||= @default_sheet\n read_cells(sheet)\n\n @fonts[sheet][normalize(row,col).to_a]\n end",
"def load_single_font(name)\n\n # Determine path to font file.\n font_file_name = name.gsub(/\\s+/, \"\")\n path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}.ttf\")\n return unless File.file?(path)\n\n # Determine variants.\n italics_path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}-Italic.ttf\")\n bold_path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}-Bold.ttf\")\n bold_italics_path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}-BoldItalic.ttf\")\n\n # Build hash of variants.\n font_hash = { normal: path }\n font_hash[:italic] = italics_path if File.file?(italics_path)\n font_hash[:bold] = bold_path if File.file?(bold_path)\n font_hash[:bold_italic] = bold_italics_path if File.file?(bold_italics_path)\n\n # Add font.\n self.font_families.update(name => font_hash)\n\n end",
"def adjusts_font_size_to_fit_width ; view.adjustsFontSizeToFitWidth ; end",
"def scale_fontsize(value)\n value * @scale\n end",
"def font(height, font_name=Gosu::default_font_name)\n @used_fonts ||= {}\n key = [font_name, height]\n if @used_fonts.include? key\n @font = @used_fonts[key]\n else\n @font = @used_fonts[key] = Gosu::Font.new(self, font_name, height)\n end\n end",
"def load_single_font(name)\n \n # Determine path to font file.\n font_file_name = name.gsub(/\\s+/, \"\")\n path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}.ttf\")\n return unless File.file?(path)\n\n # Determine variants.\n italics_path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}-Italic.ttf\")\n bold_path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}-Bold.ttf\")\n bold_italics_path = Rails.root.join('lib', 'assets', 'fonts', \"#{font_file_name}-BoldItalic.ttf\")\n\n # Build hash of variants.\n font_hash = { normal: path }\n font_hash[:italic] = italics_path if File.file?(italics_path)\n font_hash[:bold] = bold_path if File.file?(bold_path)\n font_hash[:bold_italic] = bold_italics_path if File.file?(bold_italics_path)\n\n # Add font.\n self.font_families.update(name => font_hash)\n\n end",
"def text_size s, f = font\n f.text_size s\n end",
"def text_size s, f = font\n f.text_size s\n end",
"def set_font_set_and_project\n @project = Project.find(params[:project_id])\n @font_set = @project.font_sets.find(params[:id])\n @font_families = get_font_family_array(@project)\n end",
"def entities(text)\n return Typogruby.entities(text.to_s)\n end",
"def family_list\n UIFont.familyNames.sort\n end",
"def font_size\n return nil unless @styles\n\n size_tag = @styles.xpath('//w:docDefaults//w:rPrDefault//w:rPr//w:sz').first\n size_tag ? size_tag.attributes['val'].value.to_i / 2 : nil\n end",
"def setfont(*args)\n @p.setfont(self, *args)\n end",
"def to_earth_mass(**options) = convert_to('earth-mass', **options)",
"def font(name=nil, size=nil, options={})\n cur_page.font(name, size, options)\n end",
"def change_font_italics(italicized = false)\n validate_worksheet\n\n font = get_cell_font.dup\n font.set_italic(italicized)\n update_font_references(font)\n end",
"def change_font_italics(italicized = false)\n validate_worksheet\n\n font = get_cell_font.dup\n font.set_italic(italicized)\n update_font_references(font)\n end",
"def update_font\n self.contents.font.name = @window.fontName\n #self.recalculate_maxlength\n self.refresh\n end",
"def fonts\n request('ListFonts')\n end",
"def dimensions_of(text, fonts, size = 1000)\n fonts = [fonts] unless fonts.is_a? Array\n merged_metrics = {}\n # merge the metrics last to first (so that important fonts override secondary fonts)\n fonts.length.downto(1).each do |i|\n f = get_original_font(fonts[i - 1])\n if f && f.metrics\n merged_metrics.update(get_original_font(fonts[i - 1]).metrics)\n else\n warn 'metrics of font not found!'\n end\n end\n\n metrics_array = []\n text.each_char do |c|\n metrics_array << (merged_metrics[c] || { wx: 0, boundingbox: [0, 0, 0, 0] })\n end\n metrics_array_mapped_top = [].dup\n metrics_array_mapped_bottom = [].dup\n width = 0.0\n metrics_array.each do |m|\n if (m && m[:boundingbox])\n metrics_array_mapped_top << m[:boundingbox][3]\n metrics_array_mapped_bottom << m[:boundingbox][1]\n else\n metrics_array_mapped_top << 0\n metrics_array_mapped_bottom << 0\n end\n width += (m[:wx] || m[:wy] || 0) if m\n end\n height = metrics_array_mapped_top.max\n height -=metrics_array_mapped_bottom.min\n return [height.to_f / 1000 * size, width.to_f / 1000 * size] if metrics_array[0][:wy]\n [width.to_f / 1000 * size, height.to_f / 1000 * size]\n end",
"def find_os_font_files\n if RUBY_ENGINE == 'mruby'\n # MRuby does not have `Dir` defined\n `find #{directory} -name *.ttf`.split(\"\\n\")\n else\n # If MRI and/or non-Bash shell (like cmd.exe)\n Dir[\"#{directory}/**/*.ttf\"]\n end\n end",
"def platform_font_paths\n fonts = find_os_font_files.reject do |f|\n f.downcase.include?('bold') ||\n f.downcase.include?('italic') ||\n f.downcase.include?('oblique') ||\n f.downcase.include?('narrow') ||\n f.downcase.include?('black')\n end\n fonts.sort_by { |f| f.downcase.chomp '.ttf' }\n end",
"def to_italic\n %(<em>#{self}</em>)\n end",
"def default_font_name()\n end",
"def get_font_latin_attributes(font)\n return [] unless font\n\n attributes = []\n attributes << 'typeface' << font[:_name] if ptrue?(font[:_name])\n attributes << 'pitchFamily' << font[:_pitch_family] if font[:_pitch_family]\n attributes << 'charset' << font[:_charset] if font[:_charset]\n\n attributes\n end",
"def set_font(face, size)\n @curr_font = Gauges::FontRef.get(face, size)\n end",
"def change_font_italics(italicized=false)\n validate_worksheet\n # Get copy of font object with modified italics settings\n font = deep_copy(workbook.fonts[font_id().to_s][:font])\n font = modify_font_italics(font, italicized)\n # Update font and xf array\n change_font(font)\n end",
"def calc_position_emus(worksheet)\n c_start, r_start,\n xx1, yy1, c_end, r_end,\n xx2, yy2, x_abslt, y_abslt =\n worksheet.position_object_pixels(\n @column_start,\n @row_start,\n @x_offset,\n @y_offset,\n @width * @scale_x,\n @height * @scale_y\n )\n\n # Now that x2/y2 have been calculated with a potentially negative\n # width/height we use the absolute value and convert to EMUs.\n @width_emu = (@width * 9_525).abs.to_i\n @height_emu = (@height * 9_525).abs.to_i\n\n @column_start = c_start.to_i\n @row_start = r_start.to_i\n @column_end = c_end.to_i\n @row_end = r_end.to_i\n\n # Convert the pixel values to EMUs. See above.\n @x1 = (xx1 * 9_525).to_i\n @y1 = (yy1 * 9_525).to_i\n @x2 = (xx2 * 9_525).to_i\n @y2 = (yy2 * 9_525).to_i\n @x_abs = (x_abslt * 9_525).to_i\n @y_abs = (y_abslt * 9_525).to_i\n end",
"def nice_typography(text)\n widont(amp(rubypants(text)))\n end",
"def italic; end",
"def italic; end",
"def default_font; \"example.font\"; end",
"def font=(value)\n @font = value\n end",
"def convert!\n # Fonts and headings\n semanticize_font_styles!\n semanticize_headings!\n\n # Tables\n remove_paragraphs_from_tables!\n semanticize_table_headers!\n\n # list items\n remove_paragraphs_from_list_items!\n remove_unicode_bullets_from_list_items!\n remove_whitespace_from_list_items!\n remove_numbering_from_list_items!\n end",
"def font_name()\n validate_worksheet\n @workbook.fonts[font_id()][:font][:name][:attributes][:val]\n end",
"def set_font(font_name)\n itr = @form.getFields.keySet.iterator\n while itr.hasNext\n field = itr.next\n @form.setFieldProperty(field, 'textfont', create_font(font_name), nil)\n end\n end",
"def set_font(font_name)\n itr = @form.getFields.keySet.iterator\n while itr.hasNext\n field = itr.next\n @form.setFieldProperty(field, 'textfont', create_font(font_name), nil)\n end\n end",
"def set_serif\n @serif = Serif.find(params[:id])\n end",
"def parse_emphasis\n start_line_number = @src.current_line_number\n saved_pos = @src.save_pos\n\n result = @src.scan(EMPHASIS_START)\n element = (result.length == 2 ? :strong : :em)\n type = result[0..0]\n\n if (type == '_' && @src.pre_match =~ /[[:alpha:]]-?[[:alpha:]]*\\z/) || @src.check(/\\s/) ||\n @tree.type == element || @stack.any? {|el, _| el.type == element }\n add_text(result)\n return\n end\n\n sub_parse = lambda do |delim, elem|\n el = Element.new(elem, nil, nil, location: start_line_number)\n stop_re = /#{Regexp.escape(delim)}/\n found = parse_spans(el, stop_re) do\n (@src.pre_match[-1, 1] !~ /\\s/) &&\n (elem != :em || !@src.match?(/#{Regexp.escape(delim * 2)}(?!#{Regexp.escape(delim)})/)) &&\n (type != '_' || !@src.match?(/#{Regexp.escape(delim)}[[:alnum:]]/)) && !el.children.empty?\n end\n [found, el, stop_re]\n end\n\n found, el, stop_re = sub_parse.call(result, element)\n if !found && element == :strong && @tree.type != :em\n @src.revert_pos(saved_pos)\n @src.pos += 1\n found, el, stop_re = sub_parse.call(type, :em)\n end\n if found\n @src.scan(stop_re)\n @tree.children << el\n else\n @src.revert_pos(saved_pos)\n @src.pos += result.length\n add_text(result)\n end\n end",
"def parse_fnt_file(filename)\n fontFile = File.open(filename)\n \n fontFile.each_line { |line|\n \n entries = line.split(\" \")\n \n case entries[0]\n # Info about the font\n when \"info\"\n for i in 1...entries.length\n key_value = entries[i].split(\"=\")\n case key_value[0]\n when \"size\", \"stretchH\", \"spacing\", \"outline\"\n @info[key_value[0].to_sym] = key_value[1].to_i\n when \"bold\", \"italic\", \"unicode\", \"smooth\", \"aa\"\n @info[key_value[0].to_sym] = (key_value[1].to_i == 1)\n end\n end\n \n # Info common to all characters\n when \"common\"\n for i in 1...entries.length\n key_value = entries[i].split(\"=\")\n case key_value[0]\n when \"lineHeight\", \"base\", \"scaleW\", \"scaleH\", \"pages\"\n @common[key_value[0].to_sym] = key_value[1].to_i\n when \"packed\"\n @common[key_value[0].to_sym] = (key_value[1].to_i == 1)\n end\n end\n \n # Info about the bitmap pages that contain the characters\n when \"page\"\n page = Page.new\n \n for i in 1...entries.length\n key_value = entries[i].split(\"=\")\n case key_value[0]\n when \"id\"\n page[key_value[0].to_sym] = key_value[1].to_i\n when \"file\"\n page[key_value[0].to_sym] = key_value[1].tr(\"\\\"\", \"\")\n end\n end\n \n @pages[page.id] = page\n \n # Info about individual characters\n when \"char\"\n char = Char.new\n \n for i in 1...entries.length\n key_value = entries[i].split(\"=\")\n case key_value[0]\n when \"id\", \"x\", \"y\", \"width\", \"height\", \"xoffset\", \"yoffset\", \"xadvance\", \"page\"\n char[key_value[0].to_sym] = key_value[1].to_i\n end\n end\n \n @chars[char.id] = char\n end\n }\n end",
"def build_common\n @font.encoding = 'UniJIS-UCS2-H'\n @font.names = NAMES\n # Initialize font dictionary.\n @dict.registry = 'Adobe'\n @dict.ordering = 'Japan1'\n @dict.supplement = 2\n @dict.default_width = 1000\n @dict.default_vertical_widths = [880, -1000]\n # Initialize font descriptor.\n @desc.b_box = [0, -136, 1000, 859]\n @desc.italic_angle = 0\n @desc.ascent = 859\n @desc.descent = -140\n @desc.cap_height = 769\n @desc.stem_v = 78\n end",
"def info_font(*args)\n @p.info_font(self, *args)\n end",
"def postprocess(text)\n inline_emoji(text)\n end",
"def font\n\t\treturn @font\n\tend",
"def another_print_fonts\n for index in 0..@fonts.size do\n puts \"#{index} -> #{@fonts[index]}\" # use of templating\n end\nend"
] |
[
"0.6490057",
"0.61487615",
"0.6108373",
"0.5908551",
"0.5895589",
"0.5843664",
"0.5416169",
"0.53674954",
"0.5332667",
"0.5294704",
"0.52872396",
"0.52648693",
"0.5236899",
"0.5188425",
"0.51730424",
"0.5149428",
"0.51386946",
"0.5102211",
"0.50768965",
"0.50674284",
"0.5033965",
"0.50311726",
"0.5015998",
"0.5012941",
"0.49946493",
"0.49832156",
"0.49587047",
"0.49585348",
"0.49529654",
"0.4934042",
"0.4884445",
"0.4875013",
"0.48713967",
"0.48666787",
"0.48558477",
"0.48547512",
"0.48504025",
"0.48439115",
"0.48397744",
"0.48284623",
"0.47992793",
"0.47978655",
"0.47674072",
"0.4757313",
"0.47495613",
"0.47454822",
"0.4744572",
"0.4739731",
"0.47376415",
"0.4721525",
"0.47065514",
"0.4702786",
"0.47003615",
"0.4698279",
"0.46872133",
"0.46855602",
"0.46849576",
"0.4672069",
"0.46715695",
"0.46669102",
"0.46545327",
"0.46486616",
"0.46486616",
"0.46415377",
"0.4633345",
"0.4631646",
"0.46158487",
"0.46112138",
"0.46099454",
"0.4608625",
"0.4608617",
"0.4608617",
"0.4602489",
"0.4599228",
"0.45967188",
"0.4596027",
"0.45907223",
"0.45874104",
"0.45704475",
"0.45699146",
"0.45698586",
"0.45679542",
"0.45610797",
"0.45561245",
"0.454907",
"0.454907",
"0.45257092",
"0.45106116",
"0.44978288",
"0.4497235",
"0.44938943",
"0.44938943",
"0.44937477",
"0.4483181",
"0.44783685",
"0.44739506",
"0.44708425",
"0.4470541",
"0.4467225",
"0.4465403"
] |
0.7056603
|
0
|
Indent all lines with two spaces
|
def indent_sass
puts "indenting sass"
self.sass.gsub!(/^/, " ")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def indent; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent; end",
"def indent_for(line); end",
"def with_indent ()\n thread[:indent] += 1\n yield\n ensure\n thread[:indent] -= 1\n end",
"def indent_each_line!(indent_sequence=\"\\t\")\n\t\treturn self.collect!{ |line|\t\"#{indent_sequence}#{line}\" }\n\tend",
"def indent1\n ' ' * 2\n end",
"def indent()\n #This is a stub, used for indexing\n end",
"def indentation; end",
"def indentation; end",
"def indent_atom; \" \"; end",
"def indented\n \"#{INDENTATION * indents}#{original}\"\n end",
"def indent\n return unless blank?\n write(' ' * @indentation)\n self\n end",
"def indent_out\n @indent << \" \"\n end",
"def indent\n\t\tif @marked\n\t\t\tmark_row,row = ordered_mark_rows\n\t\t\tblock_indent(mark_row,row)\n\t\telse\n\t\t\taddchar(?\\t)\n\t\tend\n\tend",
"def indent( text, spaces=4 )\n\t\tprefix = ' ' * spaces\n\t\treturn text.gsub( /(?<=\\A|\\n)/m, prefix )\n\tend",
"def indentation\n \" \" * @indent_size * @indent_level\n end",
"def indent\n @__indent__ ||= 0\n @__indent__ += indentation\n end",
"def _Indent\n _tmp = scan(/\\G(?-mix:\\t| )/)\n set_failed_rule :_Indent unless _tmp\n return _tmp\n end",
"def indent=(_arg0); end",
"def insert_indentation(line, indentation)\n line ? \" \" * indentation + line.to_s : \"\"\n end",
"def spaces\n SPACES[@indent]\n end",
"def indented\n buffer = buffer()\n buffer.indent\n nl\n yield\n nl\n buffer.unindent\n end",
"def change_indent plus\n # nothing here\n end",
"def indent!\n\t\t\tself << indent\n\t\tend",
"def with_indentation(spaces=0)\n alter do\n @with_indentation = !!spaces\n @indentation_num = spaces\n end\n end",
"def with_indentation(spaces = 0)\n alter do\n @with_indentation = !!spaces\n @indentation_num = spaces\n end\n end",
"def indent!(amount, indent_string = nil, indent_empty_lines = false)\n indent_string = indent_string || self[/^[ \\t]/] || ' '\n re = indent_empty_lines ? /^/ : /^(?!$)/\n gsub!(re, indent_string * amount)\n end",
"def indent!(amount, indent_string=nil, indent_empty_lines=false)\n indent_string = indent_string || self[/^[ \\t]/] || ' '\n re = indent_empty_lines ? /^/ : /^(?!$)/\n gsub!(re, indent_string * amount)\n end",
"def outdent(text)\n lines = text.split(\"\\n\")\n indented_with = /^ +/.match(lines.first)[0]\n lines.map { |line| line.gsub(/^#{indented_with}/, '') }.join(\"\\n\") + \"\\n\"\n end",
"def indent(str, amount=2)\n i = (\" \"*amount)\n (i + str.gsub(/\\n/, \"\\n#{i}\")).rstrip\n end",
"def unindent!\n gsub!(/^[ \\t]{#{minimum_leading_whitespace}}/, '')\n end",
"def haml_indent\n ' ' * haml_buffer.tabulation\n end",
"def indent(txt, n = 2)\n \"#{' ' * n}#{txt}\"\n end",
"def indent!(num)\n replace( ' ' * num + self.gsub(\"\\n\", \"\\n\"+' '*num))\n self\n end",
"def indent(n)\n indent = \" \" * n\n gsub '\\n', \"\\n#{indent}\"\n end",
"def formatIndents(theLines)\n\n\ttheLines.each do |theLine|\n\t\n\t\tif (theLine[:text] =~ /^(\\s+)(.*)/)\n\t\t\ttextPrefix = $1;\n\t\t\ttextSuffix = $2;\n\t\t\t\n\t\t\tnumTabs = textPrefix.size / CONFIG_TAB_WIDTH;\n\t\t\tnumSpaces = textPrefix.size % CONFIG_TAB_WIDTH;\n\n\t\t\ttheLine[:text] = (\"\\t\" * numTabs) + (\" \" * numSpaces) + textSuffix;\n\t\tend\n\n\tend\n\t\n\treturn theLines;\n\nend",
"def puts_indent(level, text)\n print \" \"*level, text, \"\\n\"\nend",
"def format_lines(lines, indentation)\n lines.gsub(/\\n/, \"\\n\" + indentation)\n end",
"def indent(str, spaces)\n str.split(\"\\n\").map { |s| (' ' * spaces) + s }.join(\"\\n\")\n end",
"def indent_all_lines(str, spaces = 2)\n return '' if str.nil? || str.blank?\n\n str.strip.split(/\\n/).map { |line| optimize_indentation(line, spaces.to_i) }.join('')\nend",
"def outdent(n)\n indent(-n)\n end",
"def outdent(n)\n indent(-n)\n end",
"def undent\n indent = split(\"\\n\").select { |line| !line.strip.empty? }.map { |line| line.index(/[^\\s]/) }.compact.min || 0\n gsub(/^[[:blank:]]{#{indent}}/, '').chomp\n end",
"def _IndentedLine\n\n _save = self.pos\n while true # sequence\n _tmp = apply(:_Indent)\n unless _tmp\n self.pos = _save\n break\n end\n _tmp = apply(:_Line)\n unless _tmp\n self.pos = _save\n end\n break\n end # end sequence\n\n set_failed_rule :_IndentedLine unless _tmp\n return _tmp\n end",
"def indent(string, amt)\n string.gsub /\\n *([^\\n]+)/m, \"\\n#{' ' * amt}\\\\1\"\n end",
"def indent( mod = nil )\n #p [ self.id, level, mod, :INDENT ]\n if level <= 0\n mod ||= 0\n else\n mod ||= options(:Indent)\n mod += ( level - 1 ) * options(:Indent)\n end\n return \" \" * mod\n\t\tend",
"def indentation_two\n arr = @lines.map { |x| x == \"\\n\" ? x = nil : x[/^\\s*/].size }\n 1.upto(arr.size - 3) do |i|\n next if arr[i].nil?\n\n @indentation[:by_two].push(i + 1) if (arr[i] % 2).odd? || arr[i] == 0\n end\n end",
"def indent(line, index)\n unless line.match(/(^$|^\\S|^( )+\\S)/)\n add_spacing_issue\n @final_spacing_string += \"indentation spacing issue at line #{index} \\n\"\n return \"indentation spacing issue at line #{index} \\n\"\n end\n nil\n end",
"def indentize!(count, char = ' ')\n tap do |s|\n s.gsub!(/([^\\n]*)(\\n|$)/) do\n s1 = Regexp.last_match(1)\n s2 = Regexp.last_match(2)\n not_empty = s1 != '' || s2 != ''\n \"#{char * count}#{s1}#{s2}\" if not_empty\n end\n end\n end",
"def adj_indent(adjust = 1)\n old, self.indent_depth = indent_depth, (indent_depth+adjust)\n self.indent_str =\n (indenting == true) ? (TAB * indent_depth) : EMPTY\n old\n end",
"def indent(prefix=\" \")\n prefix = (\" \" * prefix) if prefix.is_an? Integer\n\n if block_given?\n lines.each { |line| yield prefix + line }\n else\n lines.map { |line| prefix + line }.join('')\n end\n end",
"def increment_indent\n\t\t\t@indent[-1] += 1\n\t\tend",
"def indent_in\n @indent.slice!(-1, 1)\n end",
"def indent(times = 1)\n if ENV['TM_SOFT_TABS'] == 'NO' then \"\\t\" * times\n else ' ' * ENV['TM_TAB_SIZE'].to_i * times\n end\nend",
"def optimize_indentation(value, amount = 0)\n return \"#{value}\\n\" unless value.is_a?(String)\n \"#{value.strip_heredoc.indent(amount).chomp}\\n\"\n end",
"def optimize_indentation(value, amount = 0)\n return \"#{value}\\n\" unless value.is_a?(String)\n \"#{value.strip_heredoc.indent(amount).chomp}\\n\"\n end",
"def indent(amount, indent_string=nil, indent_empty_lines=false)\n dup.tap {|_| _.indent!(amount, indent_string, indent_empty_lines)}\n end",
"def set_default_indent(line)\n $default_indent = count_indent(line)\nend",
"def indentation_pattern()\n return /^(?: \\t)+/\n end",
"def fixed_indent(n)\n self.outdent(self.level_of_indent).indent(n)\n end",
"def indent(level=1)\n @indent_level += level\n begin\n yield\n ensure\n @indent_level -= level\n end\n end",
"def indent_content(content)\n content = content.split(\"\\n\").map do |line|\n line.blank? ? line : ' ' + line\n end\n\n content.join(\"\\n\") << \"\\n\"\n end",
"def optimize_indentation(value, amount = 0) # :doc:\n return \"#{value}\\n\" unless value.is_a?(String)\n\n if value.lines.size > 1\n value.strip_heredoc.indent(amount)\n else\n \"#{value.strip.indent(amount)}\\n\"\n end\n end",
"def tidy(data)\n indent = 0\n data.split(/\\n/).map do |line|\n line.gsub!(/^\\s*/, '')\n next if line.empty?\n indent -= 1 if line =~ /^\\s*\\}\\s*$/\n line = (' ' * (indent * 2)) + line\n indent += 1 if line =~ /\\{\\s*$/\n line\n end.compact.join(\"\\n\") + \"\\n\"\n end",
"def indent(str, indent=' ')\n str.split(\"\\n\").collect do |frag|\n \"#{indent}#{frag}\"\n end.join(\"\\n\")\n end",
"def indent(label=nil)\n iputs label if label\n old_indent = @indent_string\n @indent_string+=\" \"\n yield\n @indent_string = old_indent\n end",
"def unindent line\n if @options[:unindent] and\n @program.new_line? and\n margin = @margins.last and\n crown = @crowns.first\n then\n line.gsub(/^#{margin}/, crown)\n else\n line\n end\n end",
"def indent(amount, indent_string = nil, indent_empty_lines = false)\n dup.tap { |_| _.indent!(amount, indent_string, indent_empty_lines) }\n end",
"def indent(n)\n if n >= 0\n gsub(/^/, ' ' * n)\n else\n gsub(/^ {0,#{-n}}/, \"\")\n end\n end",
"def _OptionallyIndentedLine\n\n _save = self.pos\n while true # sequence\n _save1 = self.pos\n _tmp = apply(:_Indent)\n unless _tmp\n _tmp = true\n self.pos = _save1\n end\n unless _tmp\n self.pos = _save\n break\n end\n _tmp = apply(:_Line)\n unless _tmp\n self.pos = _save\n end\n break\n end # end sequence\n\n set_failed_rule :_OptionallyIndentedLine unless _tmp\n return _tmp\n end",
"def spacing\n puts \"\"\n puts \"\"\n puts \"\"\n end",
"def indent(text)\n text.gsub!(INDENT_REGEX, \"\\\\0#{@indent}\")\n text\n end",
"def indent(n)\n if n >= 0\n gsub(/^/, ' ' * n)\n else\n gsub(/^ {0,#{-n}}/, \"\")\n end\n end",
"def indent(n)\n if n >= 0\n gsub(/^/, ' ' * n)\n else\n gsub(/^ {0,#{-n}}/, \"\")\n end\n end",
"def indent(str, count = 2)\n str = require_string! str\n pre = ' ' * count\n\n map_lines(str) { |line| \"#{pre}#{line}\" }\n end",
"def emit_indentation()\n puts \"Transition action 'emit_indentation'\"\n end",
"def code_indent(plus = 1)\n @code_indent += plus\n yield\n @code_indent -= plus\n end",
"def indent_text( text, mod, first_line = true )\n\t\t\treturn \"\" if text.to_s.empty?\n spacing = indent( mod )\n text = text.gsub( /\\A([^\\n])/, \"#{ spacing }\\\\1\" ) if first_line\n\t\t\treturn text.gsub( /\\n^([^\\n])/, \"\\n#{spacing}\\\\1\" )\n\t\tend",
"def indent(left, right = 0, &block)\n bounds.indent(left, right, &block)\n end",
"def reindent(lines, node, corrector); end",
"def visit_indented(node)\n if NOINDENT.include?(node.type)\n visit_plain(node)\n else\n indented { visit_plain(node) }\n end\n end",
"def indent(indent, *s)\n \"#{\" \" * indent}#{s.join('')}\"\n end",
"def indent(str, depth=2)\n space = \" \"*depth\n str.split(\"\\n\").join(\"\\n#{space}\").gsub(/^ *$/, \"\")\n end",
"def with_indentation(&block) # :doc:\n @indentation += 1\n instance_eval(&block)\n ensure\n @indentation -= 1\n end",
"def indent(increase=1, statement=nil, multiline=nil)\n @indent_size ||= 2\n @indent_level ||= 0\n @indent_level += increase\n multi = @multi_indent\n @multi_indent = multiline unless multiline.nil?\n if block_given?\n yield self\n else\n say(statement)\n end\n ensure\n @multi_indent = multi\n @indent_level -= increase\n end",
"def correct_indentation(node); end",
"def unindent\n (other = dup) and other.unindent! and other\n end",
"def indent()\n file = Tempfile.new(\"out\")\n infile = Tempfile.new(\"in\")\n file.write(self.to_s)\n file.flush\n bufc = \"FOO\"\n\n tmppos = @pos\n\n message(\"Auto format #{@fname}\")\n\n if [\"chdr\", \"c\", \"cpp\"].include?(get_file_type())\n\n #C/C++/Java/JavaScript/Objective-C/Protobuf code\n system(\"clang-format -style='{BasedOnStyle: LLVM, ColumnLimit: 100, SortIncludes: false}' #{file.path} > #{infile.path}\")\n bufc = IO.read(infile.path)\n elsif get_file_type() == \"Javascript\"\n cmd = \"clang-format #{file.path} > #{infile.path}'\"\n debug cmd\n system(cmd)\n bufc = IO.read(infile.path)\n elsif get_file_type() == \"ruby\"\n cmd = \"rufo #{file.path}\"\n debug cmd\n system(cmd)\n bufc = IO.read(file.path)\n else\n return\n end\n self.update_content(bufc)\n center_on_current_line #TODO: needed?\n file.close; file.unlink\n infile.close; infile.unlink\n end",
"def outdent( str )\n\t\t\tstr.gsub( /^(\\t|[ ]{1,#{TabWidth}})/, '')\n\t\tend",
"def indent(code, level = 2)\n lines = case code\n when String then code.split(\"\\n\")\n when BlocklyInterpreter::Block then start_block_to_dsl(code).split(\"\\n\")\n when Array then deep_flatten(code).compact.flat_map { |code| code.split(\"\\n\") }\n else code\n end\n\n lines.map { |line| (\" \" * level) + line }.join(\"\\n\")\n end",
"def looper\r\n for i in 1..10\r\n puts i #Should be indented.\r\n end\r\nend",
"def unindent\n @__indent__ ||= 0\n @__indent__ -= indentation\n end",
"def strip_leading_indentation\n if (indent = leading_indentation_length) > 0\n collect { |line| line =~ /^[\\s]+[^\\s]/ ? line[indent..-1] : line }.join\n else\n self\n end\n end",
"def unindent\n gsub(/^#{self[/\\A\\s*/]}/, \"\")\n end",
"def indent2(str, count)\n if str\n char = ' '\n #(char * count) + gsub(/(\\n+)/) { $1 + (char * count) }\n str.gsub(/(\\n+)/) { $1 + (char * count) }\n end\n end",
"def unindent(text)\n lines = text.split(\"\\n\")\n lines.shift while lines.first =~ /^\\s*$/ && !lines.empty?\n lines.pop while lines.last =~ /^\\s*$/ && !lines.empty?\n min_indent = lines.reject { |ln| ln =~ /^\\s*$/ }\n .map { |ln| ln.scan(/^\\s*/) }.flatten.map(&:length).min\n lines.map { |ln| ln.sub(/^\\s{#{min_indent}}/, '') }.join(\"\\n\")\nend",
"def normalize_indentation text\n lines = text.split(\"\\n\")\n return text if lines.empty?\n\n indent = if lines[0] =~ /^(\\s+)(.+?)$/\n $1.length\n else\n 0\n end\n lines.map{|l| l[indent..-1]}.join \"\\n\"\n end",
"def change_indent plus\n super(plus)\n puts plus ? \"<li><ul class=\\\"pre\\\">\" : \"<li class =\\\"none\\\">LAST</li> </ul></li>\"\n end"
] |
[
"0.8057547",
"0.8057547",
"0.8057547",
"0.8057547",
"0.8057547",
"0.79419297",
"0.78856844",
"0.78558975",
"0.7758355",
"0.772004",
"0.77150697",
"0.77150697",
"0.75030845",
"0.7484368",
"0.74525356",
"0.73740333",
"0.73607564",
"0.7356838",
"0.7325362",
"0.73075616",
"0.7219501",
"0.7207138",
"0.71972674",
"0.7119088",
"0.70961714",
"0.7047061",
"0.7025681",
"0.70107436",
"0.69838685",
"0.692426",
"0.6876218",
"0.683652",
"0.68350095",
"0.6818682",
"0.6811364",
"0.6795894",
"0.6794594",
"0.6790102",
"0.6788586",
"0.6786062",
"0.6772773",
"0.67674774",
"0.67468625",
"0.6729684",
"0.6729684",
"0.6715903",
"0.6705262",
"0.6701042",
"0.6681512",
"0.66771877",
"0.665503",
"0.6643304",
"0.6637707",
"0.6636336",
"0.6632677",
"0.6577295",
"0.65714127",
"0.6570307",
"0.6570307",
"0.6559971",
"0.6540798",
"0.6535448",
"0.65342915",
"0.6531289",
"0.6529439",
"0.65204984",
"0.6510941",
"0.65108705",
"0.65068555",
"0.65033424",
"0.6492716",
"0.6474156",
"0.64726955",
"0.6468149",
"0.64569396",
"0.64544",
"0.64541346",
"0.6438956",
"0.6436808",
"0.6434993",
"0.64113736",
"0.6408876",
"0.6403128",
"0.6400726",
"0.6399892",
"0.63998383",
"0.6392325",
"0.6381318",
"0.6377031",
"0.6374738",
"0.6371336",
"0.6365693",
"0.63522255",
"0.63489956",
"0.63470656",
"0.6338627",
"0.63323283",
"0.62861705",
"0.62784016",
"0.6270438",
"0.62676406"
] |
0.0
|
-1
|
Replace body css rule and add it to the above rule using the sass '&'
|
def rename_body
puts "renaming sass body element"
self.sass.gsub!(/^(\s*)body\n/, "\n#{$1}&\n")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def write_unmergable_css_rules(doc, unmergable_rules) # :nodoc:\n styles = unmergable_rules.to_s\n\n unless styles.empty?\n style_tag = \"<style type=\\\"text/css\\\">\\n#{styles}</style>\"\n if body = doc.search('body')\n if doc.at_css('body').children && !doc.at_css('body').children.empty?\n doc.at_css('body').children.before(::Nokogiri::XML.fragment(style_tag))\n else\n doc.at_css('body').add_child(::Nokogiri::XML.fragment(style_tag))\n end\n else\n doc.inner_html = style_tag += doc.inner_html\n end\n end\n doc\n end",
"def css(rules)\n rules = rules.to_s.unindent\n if user_css_rules = WebApp::EventHandler.instance_variable_get(:@user_css_rules)\n rules = \"#{user_css_rules}\\n#{rules}\"\n end\n WebApp::EventHandler.instance_variable_set(:@user_css_rules, rules)\n end",
"def reset_body\n mixin({\n line_height: 1\n })\n end",
"def sass\n <<-SASS\nbody\n position : relative\n font-size : 17pt\n background-color : #3e3e3e\n color : white\n padding : 0\n margin : 0\n\n h1\n background-color : black\n color : white\n font-weight : normal\n font-size : 18pt\n padding : 4px 24px\n margin : 0\n\n span#state\n float : right\n color : #00ff00\n font-size : 14.7pt\n margin-top : 6px\n\n span#speed\n display : inline-block\n width : 140px\n text-align : center\n\n &:before\n content : \"Vitesse : \"\n\n SASS\n end",
"def add_body_css_class(css_class)\n @body_css_classes ||= []\n @body_css_classes << css_class\n end",
"def boilerplate(page)\n if page.path =~ /^\\w+\\.sass$/\n name = File.join(Config.root, 'views', 'style', $&)\n page.content = File.read(name) if File.file?(name)\n end\n end",
"def update_body_class\n html = File.read(tmpfile)\n html.sub!('<body>', \"<body class='markdown-body' style='#{BODY_CSS}'>\")\n File.open(tmpfile, 'wb') { |f| f.puts(html) }\n end",
"def add_body_css_class(css_class)\n @body_css_classes ||= []\n @body_css_classes << css_class\n end",
"def post_compile(css, settings)\n\tcss\nend",
"def at_css(*args); end",
"def at_css(*args); end",
"def compile_body(body, env, counter)\n document = Nokogiri.XML body\n\n document.css(CSS, NS).each do |node|\n method = METHODS[node.name] and send method, node, env, counter\n node.unlink\n end\n\n document.to_xhtml\n end",
"def body_css_class\n\t @body_css_classes ||= []\n\t view_css_class = [controller_path.split('/'), action_name, 'view'].flatten.join('-')\n\n\t @body_css_classes.unshift(view_css_class).join(' ')\n\tend",
"def add_css_override\n file = \"app/assets/stylesheets/admin/admin.scss\"\n template(file, file)\n end",
"def sass_page; end",
"def css\n @css ||= assemble_css\n end",
"def initialize_css_style_conversion; end",
"def assemble_css\n renderer = Liquid::Template.parse(@stylesheet.data)\n renderer.render(global_template_data, :filters => liquid_filters)\n end",
"def inject_css\n append_to_file 'app/assets/stylesheets/application.css' do\n out = \"\\n\"\n out << \"/* *= require admin_test/application_admin_test */\"\n end\n end",
"def process_stylesheets(body, directory)\n to_inline = []\n\n body.scan(STYLESHEET_PATTERN) do |stylesheet_tag|\n if path = stylesheet_tag[HREF_PATH_PATTERN, :path]\n\n indent = stylesheet_tag[INDENT_PATTERN, :indent] || \"\"\n\n absolute_path = File.absolute_path(path, directory)\n stylesheet_contents = read_file(absolute_path)\n\n to_inline << [stylesheet_tag, \"#{indent}<style>#{stylesheet_contents}\\n#{indent}</style>\"]\n end\n end\n\n to_inline.reduce(body) do |output, (tag, contents)|\n output.gsub(tag, contents)\n end\n end",
"def syntax\n\t\t\t\t:sass\n\t\t\tend",
"def replace css_rule, replacement\n tag = @document.at_css(css_rule)\n tag.replace replacement\n @document\n end",
"def box_panel_body_style(suffix)\n box_panel_params(suffix)[:body_style]\n end",
"def css=(_arg0); end",
"def css_styles\n end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def append_require_css(name)\n insert_into_file 'app/assets/stylesheets/application.css',\n \" *= require #{name}\\n\",\n before: or_rx(' *= require_tree .', ' *= require_self')\n end",
"def css(page_css) \n page_css.split(' ').each do |item|\n content_for(:css) do\n \"<link href=\\\"/stylesheets/#{page_css}.css\\\" rel='stylesheet' type='text/css'/>\\n\" \n end \n end\n end",
"def extra_body_classes\n @extra_body_classes ||= ['blacklight-' + controller.controller_name, 'blacklight-' + [controller.controller_name, controller.action_name].join('-')]\n end",
"def css\n Sass::Tree::Visitors::ToCss.new.visit(self)\n end",
"def css; end",
"def css; end",
"def css; end",
"def css_proc\n @css_proc = Proc.new if block_given?\n @css_proc\n end",
"def syntax\n :sass\n end",
"def has_jammit_css(*args)\n content_for :extra_head, include_stylesheets(*args)\n end",
"def minify_css(content)\n @css_cache[content] ||= begin\n root = SassC::Engine.new(content, @options[:sass_options])\n root.render.rstrip\n end\n end",
"def style!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 29 )\n\n type = STYLE\n channel = ANTLR3::DEFAULT_CHANNEL\n\n \n # - - - - main rule block - - - -\n # at line 359:8: 'style'\n match( \"style\" )\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__, 29 )\n\n end",
"def body(body)\n append(Body.new(body))\n end",
"def has_jammit_css(*args)\n content_for :extra_head, include_stylesheets(*args)\n nil\n end",
"def stylesheet hash = 'home'\n hash = {:id => hash} if hash.is_a? String\n hash.update :action => 'stylesheet', :format => 'css', :trailing_slash => false\n home(hash)\n end",
"def css(url=\"\")\n self.style_sheet(url)\n end",
"def compile_css(ios, mark_source=false)\n header = \"/*** %s ***/\\n\"\n Dir.glob(File.join(@ctx_app_root, \"**/*#{STYLESHEET_EXT}\")) do |file|\n if File.file? file\n ios << header % file.sub(\"#{@ctx_app_root}/\", '') if mark_source\n ios << File.read(file) << \"\\n\"\n end\n end\n ios\n end",
"def add_body_to_header\n body = @template.at_css('env|Body')\n @header_template.root.add_child(body)\n @header_template\n end",
"def starter_stylesheet\n {\n :header => [:bold, :yellow],\n :add => [:bold, :green],\n :remove => [:bold, :red],\n :range => [:bold, :magenta],\n :trailing_whitespace => [:background, :red]\n }\n end",
"def has_css(*args)\n content_for :extra_head, stylesheet_link_tag(*args)\n end",
"def css_to_scss\n Proc.new {|task| task.sub(/^#{CSS_DIR}/, SASS_DIR).\n sub(/\\.css$/, '.scss')}\nend",
"def render_body_class\n extra_body_classes.join \" \"\n end",
"def css_includes *ss\n\t\t\tss.each { |s|\n\t\t\t\tlink :rel => 'stylesheet', :media => 'all', :href => s\n\t\t\t}\n\t\tend",
"def append_js_and_css!(html)\n html.sub!(\"</head>\") do\n [\n helper.tag.style(load_xray_css.html_safe, type: \"text/css\", media: \"screen\"),\n helper.javascript_tag(load_xray_js.html_safe, \"data-xray-rails\" => true),\n $~\n ].join(\"\\n\")\n end\n end",
"def _perform(environment)\n environment.set_mixin(@name, Sass::Mixin.new(@name, @args, environment, children))\n []\n end",
"def move_css_directives\n puts \"moving css directives to top of file\"\n css_directives = \"\"\n new_sass = \"\"\n directive_indent = 0\n\n # Go through the lines rewriting paths as appropriate\n sass.each_line do |line|\n sass_line = SassLine.new(@epub, self, line.to_s, directive_indent)\n\n if sass_line.inside_css_directive?\n # NOTE: Want to indent by the line indent relative to the directive\n css_directives += (\" \" * (sass_line.indent - directive_indent) + sass_line.to_s.strip + \"\\n\")\n next\n elsif sass_line.is_css_directive?\n # NOTE: Strip whitespace as want directives at the root of the line\n css_directives += \"#{sass_line.to_s.strip}\\n\"\n # NOTE: The indent is the whitespace from the start of the line to the directive\n directive_indent = sass_line.indent\n else\n directive_indent = 0\n new_sass += \"#{sass_line.to_s}\\n\"\n end\n\n if sass_line.missing_item?\n create_manifest_entry(sass_line.old_src)\n end\n end\n\n self.sass = \"#{css_directives}\\n\\n#{new_sass}\"\n end",
"def code_highlighting_stylesheet\n Sass::Engine.new(<<STYLESHEET, syntax: :sass).render\npre\n background-color: #ccd\n margin: 0px\n padding: 0.75em\n .hll\n background-color: #ffffcc\n // Error\n .err\n border: 1px solid #FF0000\n .c\n color: #60a0b0\n font-style: italic /* Comment */\n .k\n color: #007020\n font-weight: bold /* Keyword */\n .o\n color: #666666 /* Operator */\n .cm\n color: #60a0b0\n font-style: italic /* Comment.Multiline */\n .cp\n color: #007020 /* Comment.Preproc */\n .c1\n color: #60a0b0\n font-style: italic /* Comment.Single */\n .cs\n color: #60a0b0\n background-color: #fff0f0 /* Comment.Special */\n .gd\n color: #A00000 /* Generic.Deleted */\n .ge\n font-style: italic /* Generic.Emph */\n .gr\n color: #FF0000 /* Generic.Error */\n .gh\n color: #000080\n font-weight: bold /* Generic.Heading */\n .gi\n color: #00A000 /* Generic.Inserted */\n .go\n color: #888888 /* Generic.Output */\n .gp\n color: #c65d09\n font-weight: bold /* Generic.Prompt */\n .gs\n font-weight: bold /* Generic.Strong */\n .gu\n color: #800080\n font-weight: bold /* Generic.Subheading */\n .gt\n color: #0044DD /* Generic.Traceback */\n .kc\n color: #007020\n font-weight: bold /* Keyword.Constant */\n .kd\n color: #007020\n font-weight: bold /* Keyword.Declaration */\n .kn\n color: #007020\n font-weight: bold /* Keyword.Namespace */\n .kp\n color: #007020 /* Keyword.Pseudo */\n .kr\n color: #007020\n font-weight: bold /* Keyword.Reserved */\n .kt\n color: #902000 /* Keyword.Type */\n .m\n color: #40a070 /* Literal.Number */\n .s\n color: #4070a0 /* Literal.String */\n .na\n color: #4070a0 /* Name.Attribute */\n .nb\n color: #007020 /* Name.Builtin */\n .nc\n color: #0e84b5\n font-weight: bold /* Name.Class */\n .no\n color: #60add5 /* Name.Constant */\n .nd\n color: #555555\n font-weight: bold /* Name.Decorator */\n .ni\n color: #d55537\n font-weight: bold /* Name.Entity */\n .ne\n color: #007020 /* Name.Exception */\n .nf\n color: #06287e /* Name.Function */\n .nl\n color: #002070\n font-weight: bold /* Name.Label */\n .nn\n color: #0e84b5\n font-weight: bold /* Name.Namespace */\n .nt\n color: #062873\n font-weight: bold /* Name.Tag */\n .nv\n color: #bb60d5 /* Name.Variable */\n .ow\n color: #007020\n font-weight: bold /* Operator.Word */\n .w\n color: #bbbbbb /* Text.Whitespace */\n .mb\n color: #40a070 /* Literal.Number.Bin */\n .mf\n color: #40a070 /* Literal.Number.Float */\n .mh\n color: #40a070 /* Literal.Number.Hex */\n .mi\n color: #40a070 /* Literal.Number.Integer */\n .mo\n color: #40a070 /* Literal.Number.Oct */\n .sb\n color: #4070a0 /* Literal.String.Backtick */\n .sc\n color: #4070a0 /* Literal.String.Char */\n .sd\n color: #4070a0\n font-style: italic /* Literal.String.Doc */\n .s2\n color: #4070a0 /* Literal.String.Double */\n .se\n color: #4070a0\n font-weight: bold /* Literal.String.Escape */\n .sh\n color: #4070a0 /* Literal.String.Heredoc */\n .si\n color: #70a0d0\n font-style: italic /* Literal.String.Interpol */\n .sx\n color: #c65d09 /* Literal.String.Other */\n .sr\n color: #235388 /* Literal.String.Regex */\n .s1\n color: #4070a0 /* Literal.String.Single */\n .ss\n color: #517918 /* Literal.String.Symbol */\n .bp\n color: #007020 /* Name.Builtin.Pseudo */\n .vc\n color: #bb60d5 /* Name.Variable.Class */\n .vg\n color: #bb60d5 /* Name.Variable.Global */\n .vi\n color: #bb60d5 /* Name.Variable.Instance */\n .il\n color: #40a070 /* Literal.Number.Integer.Long */\nSTYLESHEET\nend",
"def myletter\n \n end",
"def process(css, opts = T.unsafe(nil)); end",
"def process(css, opts = T.unsafe(nil)); end",
"def style=(_); end",
"def stylesheet=(new_stylesheet)\n @stylesheet = new_stylesheet\n restyle!\n subviews.each{ |subview| subview.stylesheet = new_stylesheet }\n end",
"def _morecss_append selector, rules\n @morecss[selector] ||= all_rules = {}\n rules.each do |name, value|\n name = name.downcase\n all_rules[name] = value\n end\n end",
"def stylesheet= val\n @stylesheet = val\n end",
"def normalize!\n # Read the css\n data = read\n\n sass = css_to_sass(data)\n\n # Resolve the images in the sass to there new location\n new_sass = \"\"\n\n remove_on_condition = nil\n directive_indent = -1\n sass.each_line do |line|\n line.chomp!\n\n # Get the indent size\n indent = line.sub(/^(\\s+).*$/, \"\\\\1\").size\n\n # Remove if the last indent was a directive\n if remove_on_condition\n if indent > directive_indent\n next\n end\n end\n\n # If its a css directive remove it!\n if line =~ /^\\s+@/\n directive_indent = indent\n remove_on_condition = true\n next\n end\n\n remove_on_condition = false\n\n # Grab all the url('path') definitions\n if line =~ /url\\(.*\\)/\n # Split it up into its parts\n line.gsub!(/(url\\([\"']?)(.+?)([\"']?\\))/) do |m|\n # Array for the new rule\n new_rule = [$1, nil, $3]\n src = $2\n\n # Check its not an external url\n if src !~ /^http[s]?:\\/\\// && src && src != ''\n # Delete any anchors (just incase)\n src = src.sub(/^(.*)\\#$/, \"$1\")\n\n # Build the filename\n src_item = get_item(src)\n new_rule[1] = src_item.normalized_hashed_path(:relative_to => self)\n\n # override the original string\n m.replace new_rule.join\n end\n end\n end\n new_sass += \"%s\\n\" % line\n end\n\n sass = new_sass\n\n sass = convert_fonts(sass)\n\n # Parse SASS\n engine = Sass::Engine.new(sass)\n\n # Render CSS and add it to the string\n css = engine.render\n\n write(css)\n end",
"def stylesheets(&block)\n content_for(:stylesheets, nil, &block)\n end",
"def make_css\n template = ERB.new TEMPLATE\n result = template.result binding\n (0..3).each { result.gsub!(/\\n;\\n/m, \";\\n\") }\n @result = result.gsub /^$\\n/, ''\n end",
"def g_inject_styles\n g = Guilded::Guilder.instance\n self.output_buffer.sub!( /<!-- guilded.styles -->/, stylesheet_link_tag( g.combined_css_srcs, :cache => \"cache/#{g.css_cache_name}\" ) )\n end",
"def css_class_standard(hay, needle); end",
"def body=(body); end",
"def add_stylesheet(name)\n content_for(:head) do\n stylesheet_link_tag name\n end\n end",
"def netzke_css\n %{\n <style type=\"text/css\" media=\"screen\">\n #{content_for(:netzke_css)}\n </style>} if content_for(:netzke_css).present?\n end",
"def sass_options\n @sass_options ||= {\n line_comments: false,\n syntax: :sass,\n style: :compressed\n }\n end",
"def syntax\n\t\t\t\t:scss\n\t\t\tend",
"def clear_css\n self\n end",
"def rmq_style_applied\n on_styled\n end",
"def update\n css = _combine\n\n begin\n # SCSS code executing needs to know what the current instance of Chance is,\n # so that lookups for slices, etc. work.\n Chance._current_instance = self\n\n # Step 1: parse CSS\n parser = Chance::Parser.new(css, @options)\n parser.parse\n\n # Step 2: get parsed slices, slice images as needed, generate CSS for the slices,\n # and add the CSS it generates to parsed output CSS.\n \n # note that it is saved to @slices so that the slices may be found by the SCSS\n # extensions that help find offset, etc.\n @slices = parser.slices\n slice_images\n \n imager = Chance::DataURLImager.new(parser.slices, self) # for now, only DataURLs\n \n css = parser.css + \"\\n\" + imager.css\n\n # Step 3: Create output\n engine = Sass::Engine.new(css, Compass.sass_engine_options.merge({ :syntax => :scss })) \n css = engine.render\n ensure\n Chance._current_instance = nil\n end\n\n @css = css\n end",
"def has_css(*args)\n content_for :extra_head, stylesheet_link_tag(*args)\n nil\n end",
"def extra_body_classes(extra_body_classes)\n content_for_layout :extra_body_classes, extra_body_classes\n end",
"def add_app_component_stylesheet(app_component)\n add_stylesheet_path(\"components/_#{app_component}.css\")\n end",
"def styles=(_arg0); end",
"def blueprint_css\n stylesheet_link_tag( 'screen', :media => 'screen,projection') +\n stylesheet_link_tag( 'print', :media => 'print') +\n '<!--[if IE]>'.html_safe +\n stylesheet_link_tag( 'ie', :media => 'screen,projection') +\n '<![endif]-->'.html_safe\n end",
"def compile(css, include_paths, settings)\n\tcss\nend",
"def sg_usemin_css(path, options={})\n usemin = SlimGruntHelpers::Models::UseminCss.new\n options = { alt: nil, absolute: false }.merge!(options)\n\n alt = ''\n alt = \"(#{ options[:alt] })\" unless options[:alt].nil?\n\n text = \"\\n<!-- build:css#{ alt } #{ path } -->\\n\"\n yield(usemin)\n usemin.each(options) do |link|\n text << \"#{ link }\\n\"\n end\n text << \"<!-- endbuild -->\\n\"\n end",
"def replace &block\n @rules = []\n update(&block)\n end",
"def _morecss_add selector, rules\n @morecss[selector] ||=\n rules.map do |name, value|\n [name.downcase, value]\n end.\n to_h\n end",
"def main_styles\n current_page?(photography_path) ? '' : 'height: 100vh; height: var(--app-height, 100vh);'\n end",
"def css(href)\n link :rel => 'stylesheet', :type => 'text/css', :href => href\n end",
"def css(href)\n link :rel => 'stylesheet', :type => 'text/css', :href => href\n end",
"def stylesheet(*args)\n content_for(:head) { stylesheet_link_tag(*args) }\n end",
"def sass_options(uri, importer, options)\n options.merge!(:filename => uri.gsub(%r{\\*/},\"*\\\\/\"), :syntax => :scss, :importer => importer)\n end",
"def css_impl(_roots, _parsed)\n throw 'TODO'\n end",
"def create_style_rule(rule); end",
"def stylesheet; end",
"def escape_css(string); end",
"def sanitize_css(style); end",
"def sanitize_css(style); end",
"def sanitize_css(style); end",
"def style(new_styles = {})\n @style.merge! new_styles\n end",
"def sass_options\n { \n :load_paths => [ theme_stylesheets_path, Sass::Plugin.options[:load_paths] ].flatten \n }\n end",
"def body!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 4 )\n\n type = BODY\n channel = ANTLR3::DEFAULT_CHANNEL\n\n \n # - - - - main rule block - - - -\n # at line 325:7: 'body'\n match( \"body\" )\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__, 4 )\n\n end"
] |
[
"0.57379687",
"0.569437",
"0.5649964",
"0.5635443",
"0.56238586",
"0.5512798",
"0.5507444",
"0.5490131",
"0.54834735",
"0.54481226",
"0.54481226",
"0.54370546",
"0.531204",
"0.5301126",
"0.52723217",
"0.5248213",
"0.52280563",
"0.5198434",
"0.5193462",
"0.51603824",
"0.51131797",
"0.51108724",
"0.50973004",
"0.5065465",
"0.50645214",
"0.5059625",
"0.5059625",
"0.5059625",
"0.5059625",
"0.50590104",
"0.5007022",
"0.49946797",
"0.49939778",
"0.4981656",
"0.4981656",
"0.4981656",
"0.49631494",
"0.49459597",
"0.49455696",
"0.4921971",
"0.48870292",
"0.48672903",
"0.48441115",
"0.48399386",
"0.48388204",
"0.48339814",
"0.48233885",
"0.48070696",
"0.47952968",
"0.47910735",
"0.4780415",
"0.47712436",
"0.4758159",
"0.47538283",
"0.47406736",
"0.47354037",
"0.4718497",
"0.47100282",
"0.47100282",
"0.4693401",
"0.46879324",
"0.46850643",
"0.4684702",
"0.46705467",
"0.4664859",
"0.46617052",
"0.46575624",
"0.46492335",
"0.4635002",
"0.46343845",
"0.46333656",
"0.4625298",
"0.4625199",
"0.46234235",
"0.46207312",
"0.46183848",
"0.46178305",
"0.46141192",
"0.46078664",
"0.46074963",
"0.46070755",
"0.4606788",
"0.45987278",
"0.45918015",
"0.45872357",
"0.45814377",
"0.45726",
"0.45726",
"0.4565711",
"0.45590934",
"0.45563507",
"0.45538986",
"0.45347393",
"0.45251587",
"0.45218182",
"0.45218182",
"0.45218182",
"0.451207",
"0.45079395",
"0.4504409"
] |
0.6865634
|
0
|
CSS directives must be top levl We namespace the css so these will bork So loop through identifying directives and remove them an anything indented inside
|
def move_css_directives
puts "moving css directives to top of file"
css_directives = ""
new_sass = ""
directive_indent = 0
# Go through the lines rewriting paths as appropriate
sass.each_line do |line|
sass_line = SassLine.new(@epub, self, line.to_s, directive_indent)
if sass_line.inside_css_directive?
# NOTE: Want to indent by the line indent relative to the directive
css_directives += (" " * (sass_line.indent - directive_indent) + sass_line.to_s.strip + "\n")
next
elsif sass_line.is_css_directive?
# NOTE: Strip whitespace as want directives at the root of the line
css_directives += "#{sass_line.to_s.strip}\n"
# NOTE: The indent is the whitespace from the start of the line to the directive
directive_indent = sass_line.indent
else
directive_indent = 0
new_sass += "#{sass_line.to_s}\n"
end
if sass_line.missing_item?
create_manifest_entry(sass_line.old_src)
end
end
self.sass = "#{css_directives}\n\n#{new_sass}"
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def css_omit\n %w()\nend",
"def directives; end",
"def directives; end",
"def clean_css\n return if self.css.blank?\n prefix = \"#workskin\"\n scanner = StringScanner.new(self.css)\n if !scanner.exist?(/\\/\\*/)\n # no comments, clean the whole thing\n self.css = clean_css_code(self.css, prefix)\n else\n clean_code = []\n while (scanner.exist?(/\\/\\*/))\n clean_code << (clean = clean_css_code(scanner.scan_until(/\\/\\*/), prefix))\n clean_code << '/*' + scanner.scan_until(/\\*\\//) if scanner.exist?(/\\*\\//)\n end\n clean_code << (clean = clean_css_code(scanner.rest, prefix))\n self.css = clean_code.delete_if {|code_block| code_block.blank?}.join(\"\\n\")\n end\n end",
"def namespace_by_filename\n rename_body\n indent_sass\n namespace_sass\n\n # remove the @char style css directives (can't be indented)\n move_css_directives\n puts sass\n end",
"def real_remove_pretty_printing!(exceptions=nil)\n return if exceptions and exceptions.include? @name\n each{|c|\n if c.is_a? String\n c.sub!(/^\\s+/, \"\")\n c.sub!(/\\s+$/, \"\")\n c.gsub!(/\\s+/, \" \")\n elsif c.is_a? XML_PI or c.is_a? XML_Comment\n else\n c.real_remove_pretty_printing!(exceptions)\n end\n }\n end",
"def remove_curation_concerns_scss\n remove_file 'app/assets/stylesheets/curation_concerns.css.scss'\n end",
"def process_directives\n end",
"def sanitize_css(style); end",
"def sanitize_css(style); end",
"def sanitize_css(style); end",
"def indent_sass\n puts \"indenting sass\"\n self.sass.gsub!(/^/, \" \")\n end",
"def remove_commented_out_lines\n @content = @content.gsub(%r%//.*rb_define_%, '//')\n end",
"def tidy(object, prefix)\n object.gsub!(prefix, '')\n object.chomp!(\".html\")\n \n object = @utils.partial(object, \"remove\") if object.include?('.scss') \n object.chomp!(\".scss\")\n \n object\n end",
"def clear_css\n self\n end",
"def auto_complete_css\n auto_complete_skip_style ? '' : AUTO_COMPLETE_CSS\n end",
"def clean_inline_css(url)\n premailer = Premailer.new(url, :adapter => :nokogiri, :escape_url_attributes => false)\n premailer.to_inline_css.gsub(\"Drop Content Blocks Here\", \"\")\n end",
"def remove_commented_out_lines\n @body.gsub!(%r{//.*rb_define_}, '//')\n end",
"def css_impl(_roots, _parsed)\n throw 'TODO'\n end",
"def normalize!\n # Read the css\n data = read\n\n sass = css_to_sass(data)\n\n # Resolve the images in the sass to there new location\n new_sass = \"\"\n\n remove_on_condition = nil\n directive_indent = -1\n sass.each_line do |line|\n line.chomp!\n\n # Get the indent size\n indent = line.sub(/^(\\s+).*$/, \"\\\\1\").size\n\n # Remove if the last indent was a directive\n if remove_on_condition\n if indent > directive_indent\n next\n end\n end\n\n # If its a css directive remove it!\n if line =~ /^\\s+@/\n directive_indent = indent\n remove_on_condition = true\n next\n end\n\n remove_on_condition = false\n\n # Grab all the url('path') definitions\n if line =~ /url\\(.*\\)/\n # Split it up into its parts\n line.gsub!(/(url\\([\"']?)(.+?)([\"']?\\))/) do |m|\n # Array for the new rule\n new_rule = [$1, nil, $3]\n src = $2\n\n # Check its not an external url\n if src !~ /^http[s]?:\\/\\// && src && src != ''\n # Delete any anchors (just incase)\n src = src.sub(/^(.*)\\#$/, \"$1\")\n\n # Build the filename\n src_item = get_item(src)\n new_rule[1] = src_item.normalized_hashed_path(:relative_to => self)\n\n # override the original string\n m.replace new_rule.join\n end\n end\n end\n new_sass += \"%s\\n\" % line\n end\n\n sass = new_sass\n\n sass = convert_fonts(sass)\n\n # Parse SASS\n engine = Sass::Engine.new(sass)\n\n # Render CSS and add it to the string\n css = engine.render\n\n write(css)\n end",
"def remove_styles\n\n\t\tif self.about\n\t\t self.about = self.about.gsub(/font-family[^;]*;/,'')\n\t\t self.about = self.about.gsub(/font-size[^;]*;/,'')\n\t\t self.about = self.about.gsub(/background[^;]*;/,'')\n\t\t self.about = self.about.gsub(/color[^;]*;/,'')\n\t\t self.about = self.about.gsub(/border[^;]*;/,'')\n\t\tend\n\tend",
"def strip_style_tag (s)\ns.gsub(/<style.*<\\/style>/i, '');\nend",
"def process_style_modifiers\n @doc.css('b', 'i', 'em', 'strong', 'ins', 'u', 'del', 'cite').each do |node|\n # We are getting the html of the children, we can't use {node.text} here\n # because we would be missing all the other html tags.\n text = node.children.to_s\n replacement_value = MODIFIERS[node.name.to_sym]\n\n node.replace(replacement_value + text.strip + replacement_value)\n end\n end",
"def remove_private\n # Workaround for gsub encoding for Ruby 1.9.2 and earlier\n empty = ''\n empty = RDoc::Encoding.change_encoding empty, @text.encoding\n\n @text = @text.gsub(%r%^\\s*([#*]?)--.*?^\\s*(\\1)\\+\\+\\n?%m, empty)\n @text = @text.sub(%r%^\\s*[#*]?--.*%m, '')\n end",
"def ignore_sg\n ret = []\n ret << \"styleguide/index.html\"\n ret << \"styleguide/**/index.html\"\n ret\n end",
"def css_styles\n end",
"def strip_require(file)\n output = ''\n File.foreach(file) do |line|\n output << line unless line =~ /require ('|\")ruby2d('|\")/\n end\n return output\nend",
"def strip_require(file)\n output = ''\n File.foreach(file) do |line|\n output << line unless line =~ /require ('|\")ruby2d('|\")/\n end\n return output\nend",
"def sanitize_css(style)\n\t\t\tif style !~ /^(\\s*[-\\w]+\\s*:\\s*[^:;]*(;|$)\\s*)*?$/\n\t\t\t\t\"\"\n\t\t\telse\n\t\t\t\toriginal_sanitize_css(style)\n\t\t\tend\n\t\tend",
"def sanitize_prefixed_tags_from(soap)\n soap.gsub /(m|env):/, ''\n end",
"def write_unmergable_css_rules(doc, unmergable_rules) # :nodoc:\n styles = unmergable_rules.to_s\n\n unless styles.empty?\n style_tag = \"<style type=\\\"text/css\\\">\\n#{styles}</style>\"\n if body = doc.search('body')\n if doc.at_css('body').children && !doc.at_css('body').children.empty?\n doc.at_css('body').children.before(::Nokogiri::XML.fragment(style_tag))\n else\n doc.at_css('body').add_child(::Nokogiri::XML.fragment(style_tag))\n end\n else\n doc.inner_html = style_tag += doc.inner_html\n end\n end\n doc\n end",
"def _keep_this_css_from_purging\n %(<div class=\"divider navigation mx-auto d-block bd-callout bd-callout-info tab-content tab-pane nav nav-tabs nav-item fade show active nav-link pink\"></div>)\n end",
"def stylist\n\n end",
"def generate top_levels\n top_levels.each do |top_level|\n @tags[top_level.relative_name] << [top_level.relative_name, 0, 'F']\n end\n\n RDoc::TopLevel.all_classes_and_modules.each do |klass|\n kind = \"class:#{klass.full_name}\"\n\n address =\n unless RDoc::TopLevel === klass.parent then\n \"/#{klass.type} \\\\(#{klass.parent.full_name}::\\\\)\\\\?#{klass.name}/\"\n else\n \"/#{klass.type} #{klass.full_name}/\"\n end\n\n klass.in_files.each do |file|\n @tags[klass.full_name] << [file.relative_name, address, 'c']\n @tags[klass.name] << [file.relative_name, address, 'c']\n end\n\n klass.each_attribute do |attr|\n where = [\n attr.file.relative_name,\n \"/attr\\\\w\\\\*\\\\s\\\\*\\\\[:'\\\"]#{attr.name}/\",\n 'f',\n kind\n ]\n\n @tags[attr.name] << where\n @tags[\"#{attr.name}=\"] << where\n end\n\n klass.each_constant do |constant|\n @tags[constant.name] << [\n constant.file.relative_name, \"/#{constant.name}\\\\s\\\\*=/\", 'd', kind]\n end\n\n klass.each_method do |method|\n address = if method.singleton then\n # \\w doesn't appear to work in [] with nomagic\n \"/def \\\\[A-Za-z0-9_:]\\\\+.#{method.name}/\"\n else\n \"/def #{method.name}/\"\n end\n\n @tags[method.name] << [\n method.file.relative_name, address, 'f', kind]\n end\n end\n\n unless @dry_run then\n write_tags\n merge_ctags\n end\n end",
"def unindent!\n gsub!(/^[ \\t]{#{minimum_leading_whitespace}}/, '')\n end",
"def semanticize!\n # Convert unnumbered list paragraphs to actual unnumbered lists\n doc.css(\".#{LI_SELECTORS.join(\",.\")}\").each { |node| node.node_name = \"li\" }\n\n # Try to guess heading where implicit bassed on font size\n implicit_headings.each do |element|\n heading = guess_heading element\n element.node_name = heading unless heading.nil?\n end\n\n # Removes paragraphs from tables\n doc.search(\"td p\").each { |node| node.node_name = \"span\" }\n end",
"def netzke_css\n %{\n <style type=\"text/css\" media=\"screen\">\n #{content_for(:netzke_css)}\n </style>} if content_for(:netzke_css).present?\n end",
"def smooth_offtags( text )\n unless @pre_list.empty?\n ## replace <pre> content\n text.gsub!(/<redpre#(\\d+)>/) do\n content = @pre_list[$1.to_i]\n if content.match(/<code\\s+class=\"(\\w+)\">\\s?(.+)/m)\n content = \"<code class=\\\"#{$1} syntaxhl\\\">\" + \n Redmine::SyntaxHighlighting.highlight_by_language($2, $1)\n end\n content\n end\n end\n end",
"def correct_style_detected; end",
"def correct_style_detected; end",
"def correct_style_detected; end",
"def remove_config_comment_lines\n # NOTE: (2016-02-09) jonk => don't want this\n end",
"def sourcecode_cleanup(docxml)\n docxml.xpath(\"//sourcecode\").each do |s|\n s.children = s.children.to_xml.gsub(%r{<br/>\\n}, \"\\n\")\n .gsub(%r{\\s+(<t[ >])}, \"\\\\1\").gsub(%r{</t>\\s+}, \"</t>\")\n sourcecode_remove_markup(s)\n s.children = \"<![CDATA[#{HTMLEntities.new.decode(s\n .children.to_xml.sub(/\\A\\n+/, ''))}]]>\"\n end\n end",
"def unindent\n gsub(/^#{self[/\\A\\s*/]}/, \"\")\n end",
"def scan\n remove_commented_out_lines\n do_classes\n do_constants\n do_methods\n do_includes\n do_aliases\n @top_level\n end",
"def add_inline_styles(content)\n content\n .gsub(/<(p|li)>/, '<\\1 style=\"margin-bottom: 0.5em\">')\n .gsub(/<(h2.*?)>/, '<\\1 style=\"margin-top: 1em\">') # .*? nongreedy matcher to catch the ids of h2s\n .gsub(/<(table)>/, '<\\1 style=\"margin-bottom: 1em; border-collapse: collapse;\" border=\"1\">')\n end",
"def directives\n @directives ||= load_directives\n end",
"def cleanup! xml\n ns = { 'pre' => 'info:lc/xmlns/premis-v2' }\n \n conflicts = xml.find(\"//pre:*[starts-with(@xmlID, 'agent-')]\", ns).to_a + \n xml.find(\"//pre:*[starts-with(@xmlID, 'object-')]\", ns).to_a +\n xml.find(\"//pre:*[starts-with(@xmlID, 'event-')]\", ns).to_a +\n xml.find(\"//pre:*[starts-with(@xmlID, 'bitstream-')]\", ns).to_a +\n xml.find(\"//pre:*[starts-with(@xmlID, 'representation-')]\", ns).to_a +\n xml.find(\"//pre:*[@xmlID='DPMD1']\", ns).to_a +\n xml.find(\"//pre:*[@xmlID='PREMIS_AMD']\", ns).to_a\n \n unless conflicts.empty?\n \n # prepend all IDs with 'premis_'\n xml.find(\"//pre:*[@xmlID]\", ns).each do |c| \n c['xmlID'] = \"premis_#{c['xmlID']}\"\n end\n \n # modify corresponding IDRefs\n ['RelEventXmlID', 'RelObjectXmlID', 'LinkObjectXmlID', 'LinkEventXmlID',\n 'LinkAgentXmlID', 'LinkPermissionStatementXmlID'].each do |a|\n \n xml.find(\"//pre:*[@#{a}]\", ns).each do |node|\n new_idref = node[a].split.map { |s| \"premis_#{s}\" }\n node[a] = new_idref * ' '\n end\n\n end\n \n end\n \n xml\n end",
"def clean_css_code(css_code, prefix = \"\")\n return \"\" if !css_code.match(/\\w/) # only spaces of various kinds\n clean_css = \"\"\n parser = CssParser::Parser.new\n parser.add_block!(css_code)\n prefix = prefix + \" \" unless prefix.blank?\n \n if parser.to_s.blank?\n errors.add(:base, ts(\"We couldn't find any valid CSS rules in that code.\"))\n else\n parser.each_rule_set do |rs|\n selectors = rs.selectors.map do |selector|\n if selector.match(/@font-face/i)\n errors.add(:base, ts(\"We don't allow the @font-face feature.\"))\n next\n end\n sel = selector.gsub(/\\n/, '').strip\n sel = sel.match(/^\\s*#{prefix}/) ? sel : prefix + sel\n end\n clean_declarations = \"\"\n rs.each_declaration do |property, value, is_important|\n if property.blank? || value.blank?\n errors.add(:base, ts(\"The code for #{rs.selectors.join(',')} doesn't seem to be a valid CSS rule.\"))\n elsif sanitize_css_property(property).blank?\n errors.add(:base, ts(\"We don't currently allow the CSS property #{property} -- please notify support if you think this is an error.\"))\n elsif (cleanval = sanitize_css_declaration_value(property, value)).blank?\n errors.add(:base, ts(\"The #{property} property in #{rs.selectors.join(', ')} cannot have the value #{value}, sorry!\"))\n else\n clean_declarations += \" #{property}: #{cleanval}#{is_important ? ' !important' : ''};\\n\"\n end\n end\n if clean_declarations.blank?\n errors.add(:base, ts(\"There don't seem to be any rules for #{rs.selectors.join(',')}\"))\n else\n # everything looks ok, add it to the css\n clean_css += \"#{selectors.join(\",\\n\")} {\\n\"\n clean_css += clean_declarations\n clean_css += \"}\\n\\n\"\n end\n end\n end\n return clean_css\n end",
"def directive_line!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 107 )\n\n \n # - - - - main rule block - - - -\n # at line 956:5: ( IGNORABLE )* ( HIDE | REQUIRE ) ( IGNORABLE )* ( ( '\\\\r' )? '\\\\n' )?\n # at line 956:5: ( IGNORABLE )*\n while true # decision 51\n alt_51 = 2\n look_51_0 = @input.peek( 1 )\n\n if ( look_51_0 == 0x9 || look_51_0 == 0xc || look_51_0 == 0x20 || look_51_0 == 0x2f || look_51_0 == 0x5c || look_51_0 == 0xa0 )\n alt_51 = 1\n\n end\n case alt_51\n when 1\n # at line 956:5: IGNORABLE\n ignorable!\n\n else\n break # out of loop for decision 51\n end\n end # loop for decision 51\n # at line 957:5: ( HIDE | REQUIRE )\n alt_52 = 2\n look_52_0 = @input.peek( 1 )\n\n if ( look_52_0 == 0x68 )\n alt_52 = 1\n elsif ( look_52_0 == 0x69 || look_52_0 == 0x72 )\n alt_52 = 2\n else\n raise NoViableAlternative( \"\", 52, 0 )\n end\n case alt_52\n when 1\n # at line 957:7: HIDE\n hide!\n\n when 2\n # at line 958:7: REQUIRE\n require!\n\n end\n # at line 960:5: ( IGNORABLE )*\n while true # decision 53\n alt_53 = 2\n look_53_0 = @input.peek( 1 )\n\n if ( look_53_0 == 0x9 || look_53_0 == 0xc || look_53_0 == 0x20 || look_53_0 == 0x2f || look_53_0 == 0x5c || look_53_0 == 0xa0 )\n alt_53 = 1\n\n end\n case alt_53\n when 1\n # at line 960:5: IGNORABLE\n ignorable!\n\n else\n break # out of loop for decision 53\n end\n end # loop for decision 53\n # at line 961:5: ( ( '\\\\r' )? '\\\\n' )?\n alt_55 = 2\n look_55_0 = @input.peek( 1 )\n\n if ( look_55_0 == 0xa || look_55_0 == 0xd )\n alt_55 = 1\n end\n case alt_55\n when 1\n # at line 961:7: ( '\\\\r' )? '\\\\n'\n # at line 961:7: ( '\\\\r' )?\n alt_54 = 2\n look_54_0 = @input.peek( 1 )\n\n if ( look_54_0 == 0xd )\n alt_54 = 1\n end\n case alt_54\n when 1\n # at line 961:7: '\\\\r'\n match( 0xd )\n\n end\n match( 0xa )\n\n end\n\n ensure\n # -> uncomment the next line to manually enable rule tracing\n # trace_out( __method__, 107 )\n\n end",
"def maybe_directives?; end",
"def unindent\n self.gsub(/^#{self[/\\A\\s*/]}/, \"\")\n end",
"def ignore_assets\n ret = []\n ret << [\"assets/styles/atoms/flex\", \"assets/styles/atoms/flex/*\"]\n ret << [\"assets/styles/styleguide\", \"assets/styles/styleguide/**/*\"]\n ret << \"assets/styles/**/*.liquid\"\n ret << \"assets/styles/**/*.css\"\n ret << \"assets/styles/*.scss\"\n ret\n end",
"def remove_inline_style(_permalink, node)\n node.remove_attribute('style')\n end",
"def termdef_unnest_cleanup(xmldoc)\n desgn = \"//p/admitted | //p/deprecates | //p/preferred | //p//related\"\n nodes = xmldoc.xpath(desgn)\n while !nodes.empty?\n nodes[0].parent.replace(nodes[0].parent.children)\n nodes = xmldoc.xpath(desgn)\n end\n end",
"def prepare_styles(attribs, element)\n styling = attribs['class'].to_s.split(/\\s+/)\n styling << '#' + attribs['id'] unless attribs['id'].blank?\n [].tap do |items|\n styles = attribs['style'].to_s.dup.strip\n unless styles.blank?\n items << '{%s}' % styles unless styles.blank?\n end\n items << '(%s)' % styling.join(' ') unless styling.empty?\n end.join\n end",
"def hidden_namespaces; end",
"def normalise(html)\n doc = Nokogiri::HTML(html)\n body = doc.xpath('//body')\n\n body.xpath('//script').each {|s| s.remove}\n body.xpath('//comment()').each {|c| c.remove}\n body.xpath('//text()').find_all {|t| t.to_s.strip == ''}.map(&:remove)\n body.xpath('//header').remove\n body.xpath('//footer').remove\n body.xpath('//div[@id = \"global-cookie-message\"]').remove\n body.xpath('//div[@id = \"global-header-bar\"]').remove\n body.xpath('//div[@class = \"phase-banner-alpha\"]').remove\n body.xpath('//@class').remove\n body.xpath('//@id').remove\n body.xpath('//a').xpath('//@href').remove\n body.xpath('//label').xpath('//@for').remove\n body.xpath('//input').xpath('//@name').remove\n body.xpath('//input').xpath('//@value').remove\n\n remove_attributes(body, 'data')\n remove_attributes(body, 'aria')\n\n body.to_s\n .gsub(/>\\s+/, '>')\n .gsub(/\\s+</, '<')\n .gsub('><', \">\\n<\")\n end",
"def rewriteGroups(theText)\n\n\t# Rewrite the groups\n\t#\n\t# Five blank lines between groups.\n\ttheText = theText.gsub(\t/\\n\\n+#{COMMENT_BAR_TOP}/,\n\t\t\t\t\t\t\t\"\\n\\n\\n\\n\\n\\n#{COMMENT_BAR_TOP}\");\n\n\ttheText = theText.gsub(\t/\\n\\n+(#pragma mark .*)\\n#{COMMENT_BAR_TOP}/,\n\t\t\t\t\t\t\t\"\\n\\n\\n\\n\\n\\n\\\\1\\n#{COMMENT_BAR_TOP}\");\n\n\treturn theText;\n\nend",
"def extract_css\n @dom.css(STYLE_ELEMENT_QUERY).map { |element|\n stylesheet = read_stylesheet(element)\n element.remove if stylesheet\n stylesheet\n }.compact\n end",
"def remove_non_base_statements\n remove_has_target_statements\n remove_has_body_statements\n end",
"def look_for_directives_in container, comment\n @preprocess.handle comment, container do |directive, param|\n case directive\n when 'method', 'singleton-method',\n 'attr', 'attr_accessor', 'attr_reader', 'attr_writer' then\n false # handled elsewhere\n when 'section' then\n break unless container.kind_of?(RDoc::Context)\n container.set_current_section param, comment.dup\n comment.text = ''\n break\n end\n end\n\n comment.remove_private\n end",
"def remove_style_converter(ast_node, prop_name); end",
"def prune_actionwords_by_css(scenario_css, actionword_css)\n # Collect the actionwords used by all scenarios.\n used = collect_actionwords_used(scenario_css, actionword_css)\n # Extend them with actionwords used by other used actionwords.\n used = actionwords_dependencies(actionword_css, used)\n puts \"There are a total of #{used.size} actionwords used\" if @options.verbose\n # Remove actionwords that are not used at all.\n remove_unused_actionwords(actionword_css, used)\n end",
"def scaffold_auto_complete_skip_style\n scaffold_auto_complete_options[:skip_style]\n end",
"def remove_extra_bars(contents)\n\t\t\tcontents = contents.gsub(/\\A\\|/, \"\")\n\t\t\tcontents = contents.gsub(/\\|\\Z/, \"\")\n\t\t\tcontents\n\t\tend",
"def directives\n directives = []\n directives << predecessor.directives if predecessor\n directives.flatten\n end",
"def remove_coding_comment text\n text.sub(/\\A# .*coding[=:].*$/, '')\n end",
"def strip_annotations(content)\n real_content = []\n mode = :content\n header_position = 0\n\n content.split(/\\n/, -1).each_with_index do |line, line_number|\n if mode == :header && line !~ /\\s*#/\n mode = :content\n real_content << line unless line.blank?\n elsif mode == :content\n if line =~ /^\\s*#\\s*== Route.*$/\n header_position = line_number + 1 # index start's at 0\n mode = :header\n else\n real_content << line\n end\n end\n end\n\n real_content_and_header_position(real_content, header_position)\n end",
"def controller_stylesheet_tags\n\n lo_files = []\n \n required_cc_files.each do |f|\n fn = [f,\"css\"].join(\".\")\n unless Rails.application.assets.find_asset(fn).nil?\n lo_files << stylesheet_link_tag(fn)\n end\n end\n\n lo_files.join.html_safe\n\n end",
"def parse_all\n #check for skipping the block using add on module...\n parse_spc\n if @skiper.select{|f|send(f)}.length>0\n p \"skip > #{@row}\" if @dbg[:parse]\n else\n @plt_opt= '' \n #rtn= true if @selector.select{|f|send(f)}.length>0\n rtn = true if shortcut_exec( /(^[\\t ]*)\\-([\\w\\-&\\/:#.%]*\\{.*\\}=*) *([^\\n]*)\\n/) \n rtn = true if shortcut_exec( /(^[\\t ]*)\\-([\\w\\-&\\/:#.%=]*) *([^\\n]*)\\n/) \n rtn = true if shortcut_equal( /(^[\\t ]*)=([\\w\\-&\\/:#.%=]*) *([^\\n]*)\\n/) \n \n rtn = true if get_hot_simple(/^[\\t ]*(%)([\\$\\w\\-&\\/:#.\\[\\]]+\\{.*?\\}[= ]*)([^\\n]*)\\n/)\n rtn = true if get_hot_simple(/^[\\t ]*(%)([\\$\\w\\-&\\/:#.\\[\\]]+\\{.*?\\}[= ]*)()\\n/)\n rtn = true if get_hot_simple(/^[\\t ]*(%)([\\$\\w\\-&\\/:#.\\[\\]%=]+ )([^\\n]*)\\n/) \n rtn = true if get_hot_simple(/^[\\t ]*(%)([\\$\\w\\-&\\/:#.\\[\\]%=]+)()\\n/) \n \n rtn = true if get_div(/^[\\t ]*([#.])([\\w\\-&\\/.]*\\{.*\\}[= ]*)([^\\n]*)\\n/)\n rtn = true if get_div(/^[\\t ]*([#.])([\\w\\-&\\/.]*\\{.*\\}[= ]*)()\\n/)\n rtn = true if get_div(/^[\\t ]*([#.])([\\w\\-&\\/.=]* )([^\\n]*)\\n/) \n rtn = true if get_div(/^[\\t ]*([#.])([\\w\\-&\\/.=]*)()\\n/) \n rtn = true if get_input( /^[\\t ]*(:)([\\w\\-&\\/#.]*\\{.*\\}[= ]*)([^\\n]*)\\n/)\n rtn = true if get_input( /^[\\t ]*(:)([\\w\\-&\\/#.]*\\{.*\\}[= ]*)()\\n/)\n rtn = true if get_input( /^[\\t ]*(:)([\\w\\-&\\/#.=]* )([^\\n]*)\\n/) \n rtn = true if get_input( /^[\\t ]*(:)([\\w\\-&\\/#.=]*)()\\n/) \n rtn = true if parse_hot\n rtn = true if merge_hot\n rtn = true if merge_w2x\n rtn = true if parse_set_var\n rtn = true if parse_set_mem\n rtn = true if parse_get_mem\n rtn = true if inline_tag\n rtn = true if parse_end\n if parse_tags\n rtn = nil\n elsif !rtn\n auto_close \n end\n end\n rtn\n end",
"def sanitize_whitespace_during_import!(ke)\n case ke.type\n when :text\n # reduce runs of whitespace and tabs to single space\n ke.value.gsub!(/[ \\t]+/, ' ')\n when :p, :header\n # Remove para or header outer whitespace\n # remove leading whitespace\n if(\n (fc = ke.children.first) &&\n :text == fc.type\n )\n fc.value.gsub!(/\\A[ \\t\\n]+/, '')\n if '' == fc.value\n # remove :text el if it is now empty\n ke.children.delete_at(0)\n # process ke again since there may be new leading whitespace\n sanitize_whitespace_during_import!(ke)\n end\n end\n # remove trailing whitespace\n if(\n (lc = ke.children.last) &&\n :text == lc.type\n )\n lc.value.gsub!(/[ \\t\\n]+\\z/, '')\n if '' == lc.value\n # remove :text el if it is now empty\n ke.children.delete_at(-1)\n # process ke again since there may be new trailing whitespace\n sanitize_whitespace_during_import!(ke)\n end\n end\n end\n end",
"def css; end",
"def css; end",
"def css; end",
"def filter_tags(document)\n # Filter down and get the tags.\n @tags = document.css(TAG_CSS).map(&:children).map(&:text)\n end",
"def fix_variable_declaration_order(file)\n # Spinner needs to be moved after Buttons\n # since it depends on $btn-default-bg\n #\n # also spinner-btn-hover-bg needs to be\n # before spinner-up-btn-border\n if file.include? 'Spinner'\n lines = file.split \"\\n\"\n spinner_start = lines.index {|l| l =~ /Spinner/}\n spinner_end = lines.index {|l| l =~ /Pagination/} - 1\n buttons_end = lines.index {|l| l =~ /Navs/} - 1\n\n (spinner_end - spinner_start).times do\n lines.insert(buttons_end, lines.delete_at(spinner_start))\n end\n\n spinner_btn_bg = lines.index {|l| l =~ /spinner-btn-bg:/}-1\n 3.times do\n lines.insert(spinner_btn_bg+5, lines.delete_at(spinner_btn_bg))\n end\n\n file = lines.join(\"\\n\")\n end\n file\n end",
"def clean_up_contents()\n # very minimal\n # elements = ['p', 'b', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'], attributes={})\n\n if self.contents?\n html = self.contents\n email_regex = /<p>Email:\\s+((\\w|\\-|\\_|\\.)+\\@((\\w|\\-|\\_)+\\.)+[a-zA-Z]{2,})/i\n\n html.gsub! /\\[endif\\]--/ , ''\n html.gsub! /[\\n|\\r]/ , ' '\n html.gsub! / / , ' '\n\n # this will convert UNICODE into ASCII. \n #It will also strip any possiblity of using a foreign language!\n #converter = Iconv.new('ASCII//IGNORE//TRANSLIT', 'UTF-8') \n #html = converter.iconv(html).unpack('U*').select{ |cp| cp < 127 }.pack('U*')\n # keep only the things we want.\n unless (Sanitize::Config::RELAXED[:attributes][\"table\"].include?(\"align\"))\n Sanitize::Config::RELAXED[:attributes][\"table\"] << \"align\"\n end\n\n config = Sanitize::Config::RELAXED\n if (html.encoding.name == 'ASCII-8BIT')\n config[:output_encoding] = 'ASCII'\n end\n html = Sanitize.clean( html, config)\n\n # butt up any tags\n html.gsub! />\\s+</ , '><'\n\n #remove email address lines\n html.gsub! email_regex , '<p>'\n\n # post sanitize cleanup of empty blocks\n # the order of removal is import - this is the way word stacks these elements\n html.gsub! /<i><\\/i>/ , ''\n html.gsub! /<b><\\/b>/ , ''\n html.gsub! /<\\/b><b>/ , ''\n html.gsub! /<p><\\/p>/ , ''\n html.gsub! /<p><b><\\/b><\\/p>/ , ''\n\n # misc - fix butted times\n html.gsub! /(\\d)am / , '\\1 am '\n html.gsub! /(\\d)pm / , '\\1 pm '\n # misc - remove multiple space that may cause doc specific regexs to fail (in dates for example)\n html.gsub! /\\s+/ , ' '\n\n # add new lines at the end of lines\n html.gsub! /<\\/(p|h\\d|dt|dd|dl)>/, '</\\1>' + \"\\n\"\n html.gsub! /<dl>/ , '<dl>' + \"\\n\"\n\n self.contents = html\n end\n end",
"def formatPreprocessor(theLines)\n\n\talignEndifs(\t\ttheLines);\n\talignUndefineDefine(theLines);\n\talignDefineValue(\ttheLines);\n\talignContinuations(\ttheLines);\n\n\treturn theLines;\n\nend",
"def remove_directive(dir_class)\n HasDirectives.remove_directive(@own_directives, dir_class)\n nil\n end",
"def filter(str)\n str = str.gsub(/^line.*trimming empty.*\\n/, '') # the messages about empty are overzealous, and not invalid\n str = str.gsub(/^line.*proprietary.*\\n/, '') if options[:ignore_proprietary] # if you use IE only attributes like wrap, or spellcheck or things not in standard\n str = str.gsub(/^line.*(?:Error|Warning):.*<\\/?(?:#{options[:ignored_tag_errors].join('|')})>.*\\n/, '') if options[:ignored_tag_errors] && options[:ignored_tag_errors].any?\n str = str.gsub(/^line.*(?:Error|Warning):.* attribute \\\"(?:#{options[:ignored_attribute_errors].join('|')})\\\".*\\n/, '') if options[:ignored_attribute_errors] && options[:ignored_attribute_errors].any?\n if options[:ignored_errors] && options[:ignored_errors].any? && str.gsub(/^line.*(?:Error|Warning):/, '') =~ ignored_errors_regex\n str = str.gsub(Regexp.new(/^line.*(?:Error|Warning):/.source + '.*' + ignored_errors_regex.source + '.*' + /\\n/.source), '')\n end\n str.gsub(/line [0-9]+ column [0-9]+ -/, '')\n # /line [0-9]+ column [0-9]+ - / + =~ \"line 1 column 1 - Warning: missing <!DOCTYPE> declaration\"\n end",
"def sanitize_css(style_string)\n ::Loofah::HTML5::Scrub.scrub_css(style_string)\n end",
"def remove_unparseable files\n files.reject do |file, *|\n file =~ /\\.(?:class|eps|erb|scpt\\.txt|svg|ttf|yml)$/i or\n (file =~ /tags$/i and\n File.open(file, 'rb') { |io|\n io.read(100) =~ /\\A(\\f\\n[^,]+,\\d+$|!_TAG_)/\n })\n end\n end",
"def traite_inclusions_in code\n # On regarde si le fichier a des textes inclus\n if code.match(/^[ \\t]*<-/)\n code.gsub!(/^[ \\t]*<-([a-zA-Z0-9_\\/\\.]+)$/){\n finc = search_for_included_file(\"_#{$1}\", fpath)\n \"#{traite_inclusions_in(finc)}\"\n }\n end\n return code\n end",
"def unindent(text)\n lines = text.lines\n whitespace = lines.first.scan(/^\\s*/).first\n lines.map do |l|\n l.gsub(/^#{whitespace}/, \"\")\n end.join\nend",
"def replace_less_extend(less)\n less.gsub(/\\#(\\w+) \\> \\.([\\w-]*)(\\(.*\\));?/, '@include \\1-\\2\\3;')\n end",
"def read_directive allowed\n tokens = []\n\n while tk = get_tk do\n tokens << tk\n\n if :on_nl == tk[:kind] or (:on_kw == tk[:kind] && 'def' == tk[:text]) then\n return\n elsif :on_comment == tk[:kind] or :on_embdoc == tk[:kind] then\n return unless tk[:text] =~ /\\s*:?([\\w-]+):\\s*(.*)/\n\n directive = $1.downcase\n\n return [directive, $2] if allowed.include? directive\n\n return\n end\n end\n ensure\n unless tokens.length == 1 and (:on_comment == tokens.first[:kind] or :on_embdoc == tokens.first[:kind]) then\n tokens.reverse_each do |token|\n unget_tk token\n end\n end\n end",
"def strip_annotations(content); end",
"def remove_comments(raw_html)\n raw_html.gsub(/<!--(.*?)-->/, \"\")\n end",
"def test_nokogiri_css\n err = assert_compile 'nokogiri-css.y'\n assert_warnings err, useless_terms: 1, rr_conflicts: 1\n assert_parser_unchanged 'nokogiri-css.y'\n end",
"def restore_removed_comments(corrector, offense_range, node, first_child); end",
"def sanitize!\n\t\t\t@doc.downcase!\n\t\t\t@doc.gsub!(/<style.*?\\/style>/m, '')\n\t\t\t@doc.gsub!(/<script.*?\\/script>/m, '')\n\t\t\t@doc.gsub!(/<.*?>/m, ' ')\n\t\t\t@doc.gsub!(/\\s+/, ' ')\n\t\tend",
"def extractStyleAttributes(parsed_doc)\n style_attributes = {}\n styled_tags = parsed_doc.css(\"svg[style],mjx-container[style]\")\n for styled_tag in styled_tags do\n style_attribute = styled_tag[\"style\"]\n digest = Digest::MD5.hexdigest(style_attribute)[0..15]\n style_attributes[digest] = style_attribute\n\n digest_class = \"mathjax-inline-#{digest}\"\n styled_tag[\"class\"] = \"#{styled_tag[\"class\"] || \"\"} #{digest_class}\"\n styled_tag.remove_attribute(\"style\")\n end\n return style_attributes\n end",
"def extract_declares!\n # Ensure there is a name.\n self.force_name!\n # The extracted declares.\n decls = []\n # Extract the types.\n types = []\n self.each_type {|type| types << type }\n types.each {|type| self.delete_type!(type) }\n # Renames them with the current level.\n types.each do |type|\n former = type.name\n self.extend_name!(type)\n self.replace_names_subs!(former,type.name)\n end\n # Adds the types\n decls << types\n # Extract the systemTs.\n systemTs = []\n self.each_systemT {|systemT| systemTs << systemT }\n systemTs.each {|systemT| self.delete_systemT!(systemT) }\n # Renames them with the current level.\n systemTs.each do |systemT|\n former = systemT.name\n self.extend_name!(systemT)\n self.replace_names_subs!(former,systemT.name)\n end\n # Adds the systemTs\n decls << systemTs\n # Extract the inners.\n inners = []\n self.each_inner {|inner| inners << inner }\n inners.each {|inner| self.delete_inner!(inner) }\n # Renames them with the current level.\n inners.each do |inner|\n former = inner.name\n self.extend_name!(inner)\n self.replace_names_subs!(former,inner.name)\n end\n # Adds the inners\n decls << inners\n # Extract the systemIs\n systemIs = []\n self.each_systemI {|systemI| systemIs << systemI }\n systemIs.each {|systemI| self.delete_systemI!(systemI) }\n # Renames them with the current level.\n systemIs.each do |systemI|\n former = systemI.name\n self.extend_name!(systemI)\n self.replace_names_subs!(former,systemI.name)\n end\n # Adds the systemIs\n decls << systemIs\n # Returns the extracted declares.\n return decls\n end",
"def detected_styles; end",
"def inline_styles\n parser.css(\"style\").to_a\n end",
"def filter_low_priority_errors(errors)\n list = errors.split(\"\\n\")\n list.reject! do |line|\n line.include?(\"is not approved by W3C\") ||\n line.include?('proprietary attribute \"ng-') || # AngularJS custom attributes\n line.include?(\"inserting implicit <body>\") ||\n line =~ /trimming empty <(i|em|span)>/ # Used for icons and presentation\n end\n return nil if list.size==0\n return list.join(\"\\n\")\n end",
"def fix_css_paths\n\tDir.foreach(BUILDDIR) do |file|\n\t\tif /\\.css$/.match(file) \n\t\t\tFile.open(BUILDDIR + '/' + file, 'r+') do |f|\n\t\t\t\tcss = f.read\n\t\t\t\tcss.gsub!(/url\\((.*?)\\/img\\//, 'url(/img/')\n\t\t\t\tf.rewind\n\t\t\t\tf.write(css)\n\t\t\t\tf.truncate(css.length)\n\t\t\tend\n\t\tend\n\tend\nend",
"def rules_and_comments_to_css(items, style, args)\n r = ''\n if items.size > 0\n item_strs = items.map do |item|\n item.to_css(style,\n :context => :ruleset,\n :depth => (args.depth + 1))\n end\n r << style.subrule_before\n r << item_strs.join('')\n end\n\n # Remove trailing \\n's\n r.gsub! /\\n+$/, \"\\n\"\n r\n end",
"def remove_const\n file_name = @dir + \"remove_const_list.txt\"\n printf(\"@I:generate %s\\n\",file_name)\n f = open(\"#{file_name}\",\"w\")\n comment = \"Removed constraint list\" \n Common.print_file_header(f,\"#{comment}\",$TOOL,$VERSION,\"##\") \n i = 0\n @attribute_all.each{|attribute_name,data|\n data[1].each{|const|\n f.printf(\"%s\\n\",const[0]) if const[1].RemoveFlag\n }\n }\n f.close\n end"
] |
[
"0.6319556",
"0.6056606",
"0.6056606",
"0.59757024",
"0.5853228",
"0.5581586",
"0.55681336",
"0.55295616",
"0.53764224",
"0.53764224",
"0.53764224",
"0.5369006",
"0.53676164",
"0.53469825",
"0.52993876",
"0.5289558",
"0.5286437",
"0.52749735",
"0.5210161",
"0.5190277",
"0.5165145",
"0.512647",
"0.5115462",
"0.50822836",
"0.5075693",
"0.5054578",
"0.5053948",
"0.5053948",
"0.50454754",
"0.5037598",
"0.5034622",
"0.49931747",
"0.495248",
"0.49322605",
"0.49165192",
"0.49110714",
"0.490998",
"0.49094874",
"0.49065638",
"0.49065638",
"0.49065638",
"0.49016252",
"0.49007353",
"0.48967588",
"0.48896345",
"0.48853365",
"0.48612535",
"0.48604742",
"0.4859182",
"0.4841318",
"0.48369125",
"0.48334393",
"0.4829262",
"0.48289245",
"0.4818082",
"0.4803488",
"0.47889522",
"0.47876742",
"0.47865397",
"0.4785511",
"0.47826412",
"0.47777075",
"0.47739783",
"0.47730914",
"0.476625",
"0.47650394",
"0.4759581",
"0.47591627",
"0.47460145",
"0.47440964",
"0.4743595",
"0.47347984",
"0.4724911",
"0.4724911",
"0.4724911",
"0.47189137",
"0.47185802",
"0.47085878",
"0.47055164",
"0.47031546",
"0.46990627",
"0.46940675",
"0.4693335",
"0.4690581",
"0.4684824",
"0.46794343",
"0.4678428",
"0.4675654",
"0.4673864",
"0.4668644",
"0.46657473",
"0.46619946",
"0.46613133",
"0.46606806",
"0.4657197",
"0.46567702",
"0.4653737",
"0.4650708",
"0.46491757",
"0.46472564"
] |
0.6912303
|
0
|
Add a wrapper to the sytlesheet so multiple stylesheets with same identifiers don't conflict
|
def namespace_by_filename
rename_body
indent_sass
namespace_sass
# remove the @char style css directives (can't be indented)
move_css_directives
puts sass
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def stylesheet; end",
"def add_stylesheet(doc, location)\n xml_stylesheet = Nokogiri::XML::ProcessingInstruction.new(doc, \"xml-stylesheet\", %Q{type=\"text/xsl\" href=\"#{location}\"})\n doc.root.add_previous_sibling xml_stylesheet\n doc\n end",
"def style_sheet(url=\"\")\n self.tag('css', self.tag('url', url))\n end",
"def stylesheet_link_tag(*styles)\n if (@cached_stylesheets )\n\n @cached_stylesheets = @cached_stylesheets.concat(styles)\n \"<!-- #{super(*styles)} -->\"\n else\n super(*styles)\n end\n end",
"def styles; end",
"def styles; end",
"def styles; end",
"def write_unmergable_css_rules(doc, unmergable_rules) # :nodoc:\n styles = unmergable_rules.to_s\n\n unless styles.empty?\n style_tag = \"<style type=\\\"text/css\\\">\\n#{styles}</style>\"\n if body = doc.search('body')\n if doc.at_css('body').children && !doc.at_css('body').children.empty?\n doc.at_css('body').children.before(::Nokogiri::XML.fragment(style_tag))\n else\n doc.at_css('body').add_child(::Nokogiri::XML.fragment(style_tag))\n end\n else\n doc.inner_html = style_tag += doc.inner_html\n end\n end\n doc\n end",
"def add_stylesheet(name)\n content_for(:head) do\n stylesheet_link_tag name\n end\n end",
"def include_stylesheets\n Pathname.new(StylesheetDir).find do |path|\n next unless path.file?\n if @one_file\n @outfile.puts \" <style>\"\n @outfile.puts path.read\n @outfile.puts \" </style>\"\n else\n @outfile.puts \"<link href=\\\"lib/stylesheets/#{path.basename}\\\" media=\\\"screen\\\" rel=\\\"stylesheet\\\" type=\\\"text/css\\\" />\"\n end\n end\n end",
"def starter_stylesheet\n {\n :header => [:bold, :yellow],\n :add => [:bold, :green],\n :remove => [:bold, :red],\n :range => [:bold, :magenta],\n :trailing_whitespace => [:background, :red]\n }\n end",
"def css_includes *ss\n\t\t\tss.each { |s|\n\t\t\t\tlink :rel => 'stylesheet', :media => 'all', :href => s\n\t\t\t}\n\t\tend",
"def css_styles\n end",
"def default_wrapper; end",
"def stylesheet_cache\n @stylesheet_cache ||= Hash.new(&lambda do |by_stylename,_stylename|\n by_stylename[_stylename] = Hash.new(&lambda do |by_target_class,_target_class|\n if _target_class && ! _target_class.is_a?(Class)\n _target_class = _target_class.class\n end\n\n by_target_class[_target_class] = {}\n end.weak!)\n end.weak!)\n end",
"def render_style\n \"#{style}#{yield}\"\n end",
"def render_stylesheet_includes\n return \"\".html_safe unless respond_to?(:stylesheet_links)\n \n stylesheet_links.uniq.collect do |args|\n stylesheet_link_tag(*args)\n end.join(\"\\n\").html_safe\n end",
"def styles\n @styles ||= Hash.new do |_styles, stylename|\n _styles[stylename] = Style.new\n _styles[stylename].stylename = stylename\n _styles[stylename].stylesheet = self\n _styles[stylename]\n end\n end",
"def write_style_sheet\n return unless @template.constants.include? :STYLE or\n @template.constants.include? 'STYLE'\n\n template = RDoc::TemplatePage.new @template::STYLE\n\n unless @options.css then\n open RDoc::Generator::CSS_NAME, 'w' do |f|\n values = {}\n\n if @template.constants.include? :FONTS or\n @template.constants.include? 'FONTS' then\n values[:fonts] = @template::FONTS\n end\n\n template.write_html_on(f, values)\n end\n end\n end",
"def write_style_sheet\n return unless @template.constants.include? :STYLE or\n @template.constants.include? 'STYLE'\n\n template = RDoc::TemplatePage.new @template::STYLE\n\n unless @options.css then\n open RDoc::Generator::CSS_NAME, 'w' do |f|\n values = {}\n\n if @template.constants.include? :FONTS or\n @template.constants.include? 'FONTS' then\n values[\"fonts\"] = @template::FONTS\n end\n\n template.write_html_on(f, values)\n end\n end\n end",
"def stylesheet hash = 'home'\n hash = {:id => hash} if hash.is_a? String\n hash.update :action => 'stylesheet', :format => 'css', :trailing_slash => false\n home(hash)\n end",
"def css; end",
"def css; end",
"def css; end",
"def set_styles\n self.has_styles = true\n self.twitter_style = true\n end",
"def stylesheets\n sheets = []\n sheets << settings.stylesheets.keys if settings.respond_to?('stylesheets')\n sheets << @styles if @styles\n sheets.flatten.uniq.map do |css|\n \"<link href='#{path_to_styles css }' rel='stylesheet' type='text/css'>\"\n end.join\n end",
"def write_style_sheet\n debug_msg \"Copying static files\"\n options = { :verbose => $DEBUG_RDOC, :noop => @dry_run }\n\n BUILTIN_STYLE_ITEMS.each do |item|\n install_rdoc_static_file @template_dir + item, \"./#{item}\", options\n end\n\n unless @options.template_stylesheets.empty?\n FileUtils.cp @options.template_stylesheets, '.', **options\n end\n\n Dir[(@template_dir + \"{js,images}/**/*\").to_s].each do |path|\n next if File.directory? path\n next if File.basename(path) =~ /^\\./\n\n dst = Pathname.new(path).relative_path_from @template_dir\n\n install_rdoc_static_file @template_dir + path, dst, options\n end\n end",
"def path_to_stylesheet(source, options = T.unsafe(nil)); end",
"def stylesheet= val\n @stylesheet = val\n end",
"def style_for(sheet)\n @styles ||= {}\n @styles[sheet] ||= Database::XlsGenerator::Styles.new(sheet, options)\n end",
"def stylesheet\n @stylesheet.nil? ? 'gimli.css' : @stylesheet\n end",
"def style=(_); end",
"def add_style_sheets(*sheets)\n for sheet in sheets do\n @style_sheets << \" -s #{sheet} \"\n end\n end",
"def add_style_sheets(*sheets)\n for sheet in sheets do\n @style_sheets << \" -s #{sheet} \"\n end\n end",
"def include_individual_stylesheets(bundles=[])\n tags = []\n bundles.each do |bundle| \n tags.concat bundle.files.map { |css| stylesheet_link_tag(css.path) }\n end\n tags.join(\"\\n\")\n end",
"def add_trix_scss\n return nil if options[:skip_javascript]\n\n trix_import_str = <<~TRIX_SCSS\n // Used for creating ActionText content editors\n @import 'trix/dist/trix';\n // Used for date/time selection boxes in the admin interface\n @import 'flatpickr/dist/flatpickr.min';\n\n // We need to override trix.css’s image gallery styles to accommodate the\n // <action-text-attachment> element we wrap around attachments. Otherwise,\n // images in galleries will be squished by the max-width: 33%; rule.\n .trix-content {\n .attachment-gallery {\n >action-text-attachment,\n >.attachment {\n flex: 1 0 33%;\n padding: 0 0.5em;\n max-width: 33%;\n }\n &.attachment-gallery--2,\n &.attachment-gallery--4 {\n >action-text-attachment,\n >.attachment {\n flex-basis: 50%;\n max-width: 50%;\n }\n }\n }\n action-text-attachment {\n .attachment {\n padding: 0 !important;\n max-width: 100% !important;\n }\n }\n }\n .field-unit--rich-text-area-field {\n .field-unit__field {\n width: 80%;\n }\n }\n TRIX_SCSS\n append_to_file('app/assets/stylesheets/administrate/application.scss', trix_import_str)\n end",
"def css(url=\"\")\n self.style_sheet(url)\n end",
"def nonced_stylesheet_pack_tag(*args, &block)\n opts = extract_options(args).merge(nonce: _content_security_policy_nonce(:style))\n\n stylesheet_pack_tag(*args, **opts, &block)\n end",
"def style; end",
"def style; end",
"def style; end",
"def myletter\n \n end",
"def write_style_sheet\n\t\tdebug_msg \"Copying over static files\"\n\t\tstaticfiles = %w[rdoc.css js images]\n\t\tstaticfiles.each do |path|\n\t\t\tFileUtils.cp_r( @template_dir + path, '.', :verbose => $DEBUG, :noop => $dryrun )\n\t\tend\n\tend",
"def write_style_sheet\n\t\tdebug_msg \"Copying over static files\"\n\t\tstaticfiles = %w[rdoc.css js images]\n\t\tstaticfiles.each do |path|\n\t\t\tFileUtils.cp_r( @template_dir + path, '.', :verbose => $DEBUG, :noop => $dryrun )\n\t\tend\n\tend",
"def stylist\n\n end",
"def stylesheets(*args)\n\t\t@stylesheets ||= []\n\t\targs.each do |stylesheet|\n\t\t\tunless @stylesheets.include?(stylesheet.to_s)\n\t\t\t\t@stylesheets.push(stylesheet.to_s)\n\t\t\t\tcontent_for(:head,stylesheet_link_tag(stylesheet.to_s))\n\t\t\tend\n\t\tend\n\tend",
"def stylesheets(*args)\n\t\t@stylesheets ||= []\n\t\targs.each do |stylesheet|\n\t\t\tunless @stylesheets.include?(stylesheet.to_s)\n\t\t\t\t@stylesheets.push(stylesheet.to_s)\n\t\t\t\tcontent_for(:head,stylesheet_link_tag(stylesheet.to_s))\n\t\t\tend\n\t\tend\n\tend",
"def create_definition(style); end",
"def get_stylesheet\n @stylesheet\n end",
"def stylesheets(&block)\n content_for(:stylesheets, nil, &block)\n end",
"def styles=(_arg0); end",
"def stylesheet src, attributes = {}\n link({:rel => \"stylesheet\", :href => src}.merge(attributes))\n end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def css(*args); end",
"def generate_css\n needs = affected_files.map { |m| File.extname(m)[1..-1].to_sym }\n \n original_ext = File.extname(@original_file)[1..-1]\n needs << original_ext.to_sym unless needs.include? original_ext\n\n WebifyRuby::Css.link_to = @link_to\n \n if should_write_css?\n WebifyRuby::Css.relative_from = @link_to ? nil : @css\n end\n \n css = WebifyRuby::Css.new(File.basename(@file, \".*\"), @file, *needs)\n @styles = css.result\n\n @css_file = css.write @css if should_write_css?\n end",
"def stylesheet(*args)\n content_for(:stylesheets) { stylesheet_link_tag(*args) }\n end",
"def wrapper(wrapper_class)\n content_for(:wrapper) { wrapper_class }\n end",
"def initialize_css_style_conversion; end",
"def styles\n @styles ||= Hash.new{ |h, k| h[k] = {} }\n end",
"def inline_stylesheet source\n \"<style type='text/css'>\" +\n File.read(\"#{RAILS_ROOT}/public/stylesheets/#{source}\") +\n \"</style>\"\n end",
"def include_stylesheets(*bundles) \n bundles.map! { |name| Jammit::Lite::Bundle.new(:stylesheets => name) }\n return include_individual_stylesheets(bundles) unless Rails.env.production? \n tags = bundles.map { |bundle| stylesheet_link_tag(bundle.path) }\n tags.join(\"\\n\")\n end",
"def g_inject_styles\n g = Guilded::Guilder.instance\n self.output_buffer.sub!( /<!-- guilded.styles -->/, stylesheet_link_tag( g.combined_css_srcs, :cache => \"cache/#{g.css_cache_name}\" ) )\n end",
"def compileStyleElement(parsed_doc, style_attributes, doc)\n style_content = \"\"\n style_attributes.each do |digest, style_attribute|\n style_content += \".mathjax-inline-#{digest}{#{style_attribute}}\"\n end\n style_tag = parsed_doc.at_css(\"head\").add_child(\"<style>#{style_content}</style>\")[0]\n hashStyleTag(style_tag, doc)\n end",
"def stylesheet_link_tag(*sources); end",
"def stylesheet_link_tag(*sources); end",
"def stylesheet_link_tag(*sources); end",
"def create_style_rule(rule); end",
"def add_gem_component_stylesheet(gem_component)\n add_stylesheet_path(\"govuk_publishing_components/components/_#{gem_component}.css\")\n end",
"def url_to_stylesheet(source, options = T.unsafe(nil)); end",
"def wrapper; end",
"def stylesheet_link_tag_with_engine_additions(*sources)\r\n stylesheet_link_tag_without_engine_additions(*Engines::RailsExtensions::AssetHelpers.pluginify_sources(\"stylesheets\", *sources))\r\n end",
"def assemble_css\n renderer = Liquid::Template.parse(@stylesheet.data)\n renderer.render(global_template_data, :filters => liquid_filters)\n end",
"def substitute_next_style_handles\n @styles.each do |id,style|\n next_style_id = @next_styles_hash[id]\n # skip style if there is not a \"next style\"\n next if next_style_id.nil?\n # raise error if the specified \"next style\" is not defined\n if @styles[next_style_id].nil?\n RTFError.fire(\"'#{next_style_id}' cannot be the next style for '#{id}' because '#{next_style_id}'' has not been added to the stylesheet.\")\n end # if\n style.next_style_handle = @styles[next_style_id].handle\n end # styles each\n end",
"def render_plain_styleblock(name)\n @block_html.gsub('$modifier_class', '').gsub(' class=\"\"', '').prepend('<div class=\"styleguide-styleblock\">') << '</div>'\n end",
"def apply_stylename(stylename)\n if stylesheet && stylesheet.is_a?(Teacup::Stylesheet)\n style(stylesheet.query(stylename, self))\n end\n end",
"def stylesheet(url)\n @stylesheets ||= {}\n return if @stylesheets[url]\n @stylesheets[url] = true\n end",
"def set_style()\n style = @yaml['html']['style'] || @yaml['style']\n case\n when style.nil? then ''\n when style.class == String then \"style=\\\"#{style}\\\"\"\n when style.class == Hash then\n value = style.to_a.inject([]) {|r,v| r << \"#{v[0]}: #{v[1]}\" }.join(';')\n \"style=\\\"#{value}\\\"\" \n else ''\n end \nend",
"def set_style()\n style = @yaml['html']['style'] || @yaml['style']\n case\n when style.nil? then ''\n when style.class == String then \"style=\\\"#{style}\\\"\"\n when style.class == Hash then\n value = style.to_a.inject([]) {|r,v| r << \"#{v[0]}: #{v[1]}\" }.join(';')\n \"style=\\\"#{value}\\\"\" \n else ''\n end \nend",
"def add_style(style_str, screen)\n if screen\n styles_pool[screen] ||= []\n styles_pool[screen] << style_str unless styles_pool[screen].include?(style_str)\n else\n styles_pool[:_common] ||= []\n styles_pool[:_common] << style_str unless styles_pool[:_common].include?(style_str)\n end\n end",
"def has_jammit_css(*args)\n content_for :extra_head, include_stylesheets(*args)\n end",
"def compile_css(ios, mark_source=false)\n header = \"/*** %s ***/\\n\"\n Dir.glob(File.join(@ctx_app_root, \"**/*#{STYLESHEET_EXT}\")) do |file|\n if File.file? file\n ios << header % file.sub(\"#{@ctx_app_root}/\", '') if mark_source\n ios << File.read(file) << \"\\n\"\n end\n end\n ios\n end",
"def get_stylesheet\n # Filters the name of current stylesheet.\n apply_filters('stylesheet', get_option('stylesheet'))\n end",
"def add_style(style)\n '<span style=\"' + style + '\">' + self + \"</span>\"\n end",
"def wrapper\n self::Wrapper\n end",
"def stylesheet(*args)\n content_for(:head) { stylesheet_link_tag(*args) }\n end",
"def stylesheet_tag(source, options)\n tag(\"link\", { \"rel\" => \"stylesheet\", \"media\" => \"screen\", \"href\" => html_escape(path_to_stylesheet(source)) }.merge(options), ::SKIP_SELF_CLOSE_TAGS, false)\n end",
"def wrapper(name); end",
"def render_style(text, mediatype=\"all\")\n [\"<style type='text/css' media='#{mediatype}' >\",\n text,\n \"</style>\\n\"].join(\"\\n\") \n end",
"def stylesheet_entrypoint_pack_tag(*names, **options)\n unless Webpacker.dev_server.running? && Webpacker.dev_server.hot_module_replacing?\n stylesheet_link_tag(*sources_from_pack_manifest_entrypoints(names, type: :stylesheet), **options)\n end\n end",
"def stylesheet(*args)\n head { stylesheet_link_tag *args }\n end",
"def add_list_definition(style); end",
"def add_import_to_stylesheet_manifest(filename, opts = {})\n log :import_stylesheet_into_manifest\n sentinel = \"\\n@import \\\"#{filename}\\\";\"\n options = { after: \"@import \\\"#{opts[:after]}\\\";\", verbose: false }\n\n in_root do\n inject_into_file \"app/assets/stylesheets/application.css.scss\", sentinel, options\n end\n end",
"def add_app_component_stylesheet(app_component)\n add_stylesheet_path(\"components/_#{app_component}.css\")\n end",
"def style\n end",
"def css=(_arg0); end",
"def at_css(*args); end",
"def at_css(*args); end",
"def use_style=(style)\n end",
"def stylesheet\n if Symbol === @stylesheet\n @stylesheet = Teacup::Stylesheet[@stylesheet]\n end\n\n @stylesheet\n end"
] |
[
"0.5955989",
"0.584337",
"0.57436407",
"0.5674028",
"0.5650319",
"0.5650319",
"0.5650319",
"0.5633989",
"0.5601928",
"0.5593755",
"0.5503194",
"0.5490732",
"0.5478746",
"0.54247344",
"0.5405826",
"0.539675",
"0.5390448",
"0.538945",
"0.53697157",
"0.5367086",
"0.5365855",
"0.5353185",
"0.5353185",
"0.5353185",
"0.53447676",
"0.5331312",
"0.5318492",
"0.52865565",
"0.52784276",
"0.52704847",
"0.526718",
"0.52610433",
"0.52579343",
"0.52579343",
"0.52506196",
"0.52398306",
"0.5217376",
"0.5212669",
"0.518568",
"0.518568",
"0.518568",
"0.51708764",
"0.51580745",
"0.51580745",
"0.5156123",
"0.51537716",
"0.51537716",
"0.51506567",
"0.5127968",
"0.512293",
"0.5122883",
"0.51044726",
"0.509101",
"0.509101",
"0.509101",
"0.509101",
"0.50840634",
"0.5082455",
"0.50790805",
"0.5076494",
"0.5076258",
"0.50739664",
"0.5071092",
"0.5070024",
"0.50575036",
"0.5043355",
"0.5043355",
"0.50397414",
"0.5037302",
"0.50371486",
"0.50366104",
"0.50365156",
"0.50360453",
"0.5028414",
"0.5025278",
"0.50153565",
"0.5010477",
"0.49960253",
"0.4988476",
"0.4988476",
"0.49795246",
"0.49770588",
"0.4977009",
"0.49722305",
"0.49652994",
"0.49632242",
"0.49528602",
"0.49504313",
"0.49502558",
"0.49480882",
"0.49422058",
"0.4936924",
"0.49348813",
"0.49320152",
"0.4924151",
"0.49236643",
"0.4922559",
"0.49066544",
"0.49066544",
"0.4905153",
"0.49043718"
] |
0.0
|
-1
|
Creates a new logger
|
def initialize(pipe, *args)
super(pipe, *args)
self.io = pipe
self.show_backtraces = true
self.show_progress = false
self.level = WARN
self.formatter = method(:format_log)
self.warned = false
@progress_indicator = 0
@mutex = Mutex.new
@progress_msg = nil
@progress_last_update = Time.now
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create_logger\n raise \"You should create your own `create_logger` method\"\n end",
"def create_logger\n raise \"You should create your own `create_logger` method\"\n end",
"def create(name = nil)\n logger_name = name || caller(1..1).first[/`(.+)'/, 1]\n Logger.new(logger_name)\n end",
"def create(name, level = ::Logger::INFO)\n dir = \"#{Bitcoin.base_dir}/log\"\n FileUtils.mkdir_p(dir)\n logger = ::Logger.new(dir + \"/#{name}.log\", 10)\n logger.level = level\n logger.formatter = proc do |severity, datetime, progname, msg|\n Format % [severity[0..0], format_datetime(datetime), $$,\n Thread.current.object_id, severity, progname, msg2str(msg)]\n end\n logger\n end",
"def create_logger(conf)\n name = self.class.to_s\n @logger = Patriot::Util::Logger::Factory.create_logger(name, conf)\n end",
"def new_logger(path)\n if path.is_a? String\n FileUtils.touch path # prevent autocreate messages in log\n Logger.new path\n elsif path.is_a? Array\n log_file, logs_files_to_keep, log_files_max_size, * = path\n FileUtils.touch log_file # prevent autocreate messages in log\n Logger.new(log_file, logs_files_to_keep, log_files_max_size)\n end\n end",
"def create_logger(outputter=STDOUT, level=Logger::INFO)\n LOGGER.set_logger(Logger.new(outputter, level))\n end",
"def create_logger\r\n new_logger = Log4r::Logger.new(\"SAF\")\r\n new_logger.outputters = [Log4r::Outputter.stdout]\r\n Log4r::Outputter.stdout.formatter = SAFSTDOUTFormatter.new\r\n\r\n return new_logger\r\n end",
"def log_create(p_args)\n Logging::create_log(p_args)\n end",
"def logger log_name, resource, labels = {}\n Logger.new self, log_name, resource, labels\n end",
"def create_logger path\n #path = File.join(ENV[\"LOGDIR\"] || \"./\" ,\"canis14.log\")\n _path = File.open(path, File::WRONLY|File::TRUNC|File::CREAT) \n logg = Logger.new(_path)\n raise \"Could not create logger: #{path}\" unless logg\n # if not set, will default to 0 which is debug. Other values are 1 - info, 2 - warn\n logg.level = ENV[\"CANIS_LOG_LEVEL\"].to_i\n colors = Ncurses.COLORS\n logg.info \"START #{colors} colors -- #{$0} win: #{@window} : log level: #{logg.level}. To change log level, increase CANIS_LOG_LEVEL in your environment to 1 or 2 or 3.\"\n return logg\n end",
"def logger\n @logger ||= create_logger\n end",
"def logger\n @logger ||= create_logger\n end",
"def logger\n return @local_logger if @local_logger\n FileUtils.mkdir_p(File.dirname(log_path)) unless File.exists?(File.dirname(log_path))\n\n if API_KEYS[\"logentries\"]\n token = API_KEYS[\"logentries\"][Rails.env][\"nsc\"]\n @local_logger = Le.new(token, :debug => false, :local => log_path, :ssl => true, :tag => true)\n else\n @local_logger = Logger.new(log_path)\n end\n @local_logger\n end",
"def logger\n Logger.new(files[:logfile], 10, 1024000)\n end",
"def logger(name = self.class.name)\n Logger.new(name)\n end",
"def initialize_log(log_target = STDOUT)\n oldlogger ||= nil\n @logger = Logger.new(log_target)\n @logger.level = Logger::INFO\n oldlogger.close if oldlogger && !$TESTING # don't want to close testing's STDOUT logging\n @logger\n end",
"def create_logger\n l = self['logger']\n\n if l == true or l.nil?\n ::Logger.new(production? ? project_path('production.log') : STDOUT)\n elsif l.is_a?(Class)\n l.new(production? ? project_path('production.log') : STDOUT)\n elsif l.is_a?(Proc)\n l.call\n elsif l\n raise 'bad logger configure, should be: `true` / `false` / Class / Proc'\n end\n end",
"def new_logger(name, logdev, loglvl)\n logdev = [ global_logdev(name), logdev, $stderr ].find { |e| e }\n loglvl = [ global_loglvl(name), loglvl, Logger::INFO ].find { |e| e }\n logger = Logger.new(logdev)\n logger.level = loglvl\n logger.formatter = proc { |sev, datetime, progname, msg|\n \"#{name}: #{msg}\\n\"\n }\n children[name] = { logdev: logdev, loglvl: loglvl }\n logger\n end",
"def initialize_logger\n return if @logger.blank?\n log = @logger\n log = log.to_s if log.is_a?(Pathname)\n if log.is_a?(String)\n log = File.join(TMP_ROOT_DIR, log) unless log.start_with?('/')\n @logger =\n Logger.new(log).tap { |l| l.level = Logger.const_get(@log_level) }\n end\n unless @logger.is_a?(Logger)\n raise \"expected String, got #{log.class} #{log.inspect}\"\n end\n end",
"def create_logfile\n LibLog.create_logfile(ClientConfig::LOGGING,\n ClientConfig::LOG_LOCATION,\n ClientConfig::LOG_FILENAME)\n end",
"def create_logger\n transform_log_dir = Pathname.new(\"edi/logs/out\").join(Time.now.strftime(\"%Y_%m_%d\"), 'transformers')\n transform_log_dir.mkpath\n EdiHelper.make_transform_log(transform_log_dir.to_s,\n @filename + \"_\" +\n Time.now.strftime(\"%m_%d_%Y_%H_%M_%S\") +\n \".log\", 'out')\n end",
"def create_logger\n\n logger_level = settings[\"log.level\"] || \"info\"\n\n # log everything to STDERR or specified logfile\n logger = Yell::Logger.new(:null)\n logger.format = logger_format\n logger.level = logger_level\n\n logger_destination = settings[\"log.file\"] || \"STDERR\"\n # We intentionally repeat the logger_level\n # on the adapter, so it will stay there if overall level\n # is changed.\n case logger_destination\n when \"STDERR\"\n logger.adapter :stderr, level: logger_level, format: logger_format\n when \"STDOUT\"\n logger.adapter :stdout, level: logger_level, format: logger_format\n else\n logger.adapter :file, logger_destination, level: logger_level, format: logger_format\n end\n\n\n # ADDITIONALLY log error and higher to....\n if settings[\"log.error_file\"]\n logger.adapter :file, settings[\"log.error_file\"], :level => 'gte.error'\n end\n\n return logger\n end",
"def create_logger\n\n logger_level = settings[\"log.level\"] || \"info\"\n\n # log everything to STDERR or specified logfile\n logger = Yell::Logger.new(:null)\n logger.format = logger_format\n logger.level = logger_level\n\n logger_destination = settings[\"log.file\"] || \"STDERR\"\n # We intentionally repeat the logger_level\n # on the adapter, so it will stay there if overall level\n # is changed.\n case logger_destination\n when \"STDERR\"\n logger.adapter :stderr, level: logger_level, format: logger_format\n when \"STDOUT\"\n logger.adapter :stdout, level: logger_level, format: logger_format\n else\n logger.adapter :file, logger_destination, level: logger_level, format: logger_format\n end\n\n\n # ADDITIONALLY log error and higher to....\n if settings[\"log.error_file\"]\n logger.adapter :file, settings[\"log.error_file\"], :level => 'gte.error'\n end\n\n return logger\n end",
"def logger\n @logger ||= Testable::Logger.new.create\n end",
"def logger\n @logger ||= Testable::Logger.new.create\n end",
"def build_logger\n path = Hanami.root.join(\"log\", [\"emergency_log.\", Hanami.env].join)\n Logger.new(path)\n end",
"def create_logger(job_id)\n log_file_path = File.join(JOB_LOG_DIR, \"job_#{job_id}.log\")\n logger = Logger.new(log_file_path)\n logger.formatter = proc do |severity, datetime, progname, msg|\n \"#{datetime.strftime(\"%Y-%m-%d %H:%M:%S\")} : #{severity} : #{msg}\\n\"\n end\n return logger\n end",
"def logger\n @logger ||= _new_logger\n end",
"def logger\n return @logger if defined?(@logger) && !@logger.nil?\n path = log_path\n FileUtils.mkdir_p(File.dirname(path))\n prepare_logger(path)\n rescue\n prepare_logger(STDOUT)\n end",
"def logger\n @_logger ||= ::Logger.new(log_file)\n end",
"def logger\n dir = File.dirname(\"#{Rails.root}/log/#{self.id}/game.log\")\n FileUtils.mkdir_p(dir) unless File.directory?(dir)\n @logger ||= Logger.new(\"#{Rails.root}/log/#{self.id}/game.log\")\n end",
"def logger\n @logger ||= build_logger\n end",
"def add_logger(arg)\n key = nil\n logger = nil\n io = nil\n if arg.is_a? String\n # We have a filename\n key = File.basename(arg)\n\n # Try to create the logger.\n io = File.new(arg, File::WRONLY | File::APPEND | File::CREAT)\n logger = Logger.new(io)\n\n # Initialize logger\n io.write \"Logging to '#{arg}' initialized with level #{string_level(@default_level)}.\\n\"\n logger.level = convert_level(@default_level)\n else\n # We have some other object - let's hope it's an IO object\n key = nil\n case arg\n when STDOUT\n key = 'STDOUT'\n when STDERR\n key = 'STDERR'\n else\n key = arg.to_s\n end\n\n # Try to create the logger.\n io = arg\n logger = Logger.new(io)\n\n # Initialize logger\n io.write \"Logging to #{key} initialized with level #{string_level(@default_level)}.\\n\"\n logger.level = convert_level(@default_level)\n end\n\n # Set the logger formatter\n logger.formatter = @formatter\n\n # Extend logger instances with extra functionality\n logger.extend(::TeeLogger::LoggerExtensions)\n logger.teelogger_io = io\n logger.flush_interval = DEFAULT_FLUSH_INTERVAL\n\n # Flush the \"Logging to...\" line\n logger.flush\n\n if not key.nil? and not logger.nil? and not io.nil?\n @loggers[key] = logger\n @ios[key] = io\n end\n end",
"def setup_log(type=:memory)\n case type\n when :memory\n @log_content = StringIO.new\n @logger = Logger.new(@log_content)\n else\n unless defined?(@@log_file_base_name)\n @@log_file_base_name = File.normalize_path(File.join(Dir.tmpdir, \"#{File.basename(__FILE__, '.rb')}_#{Time.now.strftime(\"%Y-%m-%d-%H%M%S\")}\"))\n @@log_file_index = 0\n end\n @@log_file_index += 1\n @log_file_name = \"#{@@log_file_base_name}_#{@@log_file_index}.log\"\n @log_file = File.open(@log_file_name, 'w')\n @logger = Logger.new(@log_file)\n end\n\n @logger.level = is_debug? ? Logger::DEBUG : Logger::INFO\n return @logger\n end",
"def create_logger\n logger = Log4r::Logger.new(\"rrproxy\")\n log_format = Log4r::PatternFormatter.new(:pattern => \"[%d : %l] %m\")\n logger.add(Log4r::StdoutOutputter.new(\"console\", :formatter => log_format))\n logger.level = Log4r::INFO\n logger\nend",
"def logger\n @logger ||= Logger.new(@log_file_name)\n\n @logger.formatter = proc do |severity, datetime, progname, msg|\n \"%s, [%s #%d] (%s) %5s -- %s: %s\\n\" % [severity[0..0], datetime, $$, Conf.global_conf[:hostname], severity, progname, msg]\n end\n\n if Conf.global_conf[:debug]\n @logger.level = Logger::DEBUG\n else\n @logger.level = Logger::INFO\n end\n @logger\n end",
"def new_tagged_logger; end",
"def log\n @logger ||= Logger.new(nil)\n @logger\n end",
"def new(context)\n dup.tap do |logger|\n logger.context = \"#{logger.context}#{context_separator}#{context}\"\n end\n end",
"def log\n unless self.class._slflogger\n self.class.createlogger\n end\n return self.class._slflogger\n end",
"def setup_logger(log_name)\n date = Time.new.localtime.strftime('%F %H.%M.%S%L')\n logger = Logger.new(\"#{$VALUE}/test_logs/#{log_name}_#{date}.log\")\n logger.formatter = proc do |severity, datetime, _progname, msg|\n date_format = datetime.strftime('%Y-%m-%d %H:%M:%S%L')\n if (severity == 'INFO') || (severity == 'WARN')\n \"[#{date_format}] #{severity} (#{ENV['PRODUCT_NAME']}): #{msg}\\n\"\n else\n \"[#{date_format}] #{severity} (#{ENV['PRODUCT_NAME']}): #{msg}\\n\"\n end\n end\n logger\nend",
"def define_logger(logger)\n return logger if logger.kind_of?(Logger)\n\n Logger.new(logger)\n end",
"def define_logger(logger)\n return logger if logger.kind_of?(Logger)\n\n Logger.new(logger)\n end",
"def logger\n initialize_logger unless @logger\n @logger\n end",
"def initialize_logger()\n case logger_type\n when :local\n log_path = File.join(RAILS_ROOT, 'log', \"#{config_basename}.log\")\n system(\"cat /dev/null > #{log_path}\")\n ActiveSupport::BufferedLogger.new(log_path)\n when :remote\n RemoteLogger.new(config_basename, File.join(RAILS_ROOT, 'log'), proc_id)\n when :stderr\n logger = ActiveSupport::BufferedLogger.new($stderr)\n logger.auto_flushing = true\n logger\n else\n raise ArgumentError, \"logger_type must be :local,:remote or :stderr\"\n end\n end",
"def initialize_logger()\n case logger_type\n when :local\n log_path = File.join(RAILS_ROOT, 'log', \"#{config_basename}.log\")\n system(\"cat /dev/null > #{log_path}\")\n ActiveSupport::BufferedLogger.new(log_path)\n when :remote\n RemoteLogger.new(config_basename, File.join(RAILS_ROOT, 'log'), proc_id)\n when :stderr\n logger = ActiveSupport::BufferedLogger.new($stderr)\n logger.auto_flushing = true\n logger\n else\n raise ArgumentError, \"logger_type must be :local,:remote or :stderr\"\n end\n end",
"def initialize_logger()\n case logger_type\n when :local\n log_path = File.join(RAILS_ROOT, 'log', \"#{config_basename}.log\")\n system(\"cat /dev/null > #{log_path}\")\n ActiveSupport::BufferedLogger.new(log_path)\n when :remote\n RemoteLogger.new(config_basename, File.join(RAILS_ROOT, 'log'), proc_id)\n when :stderr\n logger = ActiveSupport::BufferedLogger.new($stderr)\n logger.auto_flushing = true\n logger\n else\n raise ArgumentError, \"logger_type must be :local,:remote or :stderr\"\n end\n end",
"def log_file_creation()\n\tcurrent_path = File.dirname(File.realpath(__FILE__))\n\t$csv_path = \"#{current_path}/Attachments.csv\"\n\tif !File.directory?(\"#{current_path}/logs\")\n\t\tFileUtils.mkdir_p \"#{current_path}/logs\"\n\tend\n\t$log_path = \"#{current_path}/logs/jira-attachment-upload.txt\"\n\t$log = Logger.new(\"#{current_path}/logs/jira-attachment-upload.txt\", 'daily')\nend",
"def initialize_logger(logging_directory, log_file_name, logging_level)\n logger = Logger.new(\"#{logging_directory}/#{log_file_name}\", 100, 1048576) # Keep last 100 log files, rotating them when they reach 1MB in size.\n logger.level = filter_logging_level logging_level\n # Suppress the default logging chatter.\n logger.formatter = proc do |severity, datetime, progname, msg|\n \"#{msg}\\n\"\n end\n\n logger\n end",
"def setupLog(fileName)\n\t# Setting up logging feature\n\tlogFile = File.open(fileName, 'w')\n\tlog = Logger.new(logFile)\n\tlog.formatter = proc do |severity, datetime, progname, msg|\n\t Time.now.asctime + \":: #{msg}\\n\"\n\tend\n\treturn log\nend",
"def make_own_logger(new_progname = nil, new_level = nil)\n new_logger = @logger || self.logger.dup\n if new_progname\n new_logger.progname = new_progname\n end\n if new_level\n new_logger.level = new_level\n end\n self.logger = new_logger\n end",
"def initialize\n @logger = Logger.new('cf_flattener.log')\n end",
"def init_logs\n begin\n if !@cloud.log_directory.nil?\n node_log_file = @cloud.log_directory + \"/#{@name.to_s}.log\"\n if !File.exists?(node_log_file)\n File.new(node_log_file, \"a+\")\n @log_file = node_log_file\n @logger.info \"Created #{node_log_file}\"\n end\n outputter = Log4r::FileOutputter.new(\"#{@name.to_s}-file\", :formatter => FileFormatter.new, :filename => node_log_file, :truncate => false)\n @logger.add(outputter)\n end\n rescue RuntimeError => rerr\n if !rerr.message.eql?(\"Maestro not configured correctly. Either RAILS_ROOT, Rails.root, or ENV['MAESTRO_DIR'] must be defined\")\n @logger.error \"Unexpected Error\"\n @logger.error rerr\n end\n rescue SystemCallError => syserr\n @logger.error \"Error creating Node log file\"\n @logger.error syserr\n rescue StandardError => serr\n @logger.error \"Unexpected Error\"\n @logger.error serr\n end\n end",
"def initialize(filename, level, rotation=10, max_size=1024000)\n # create the directory for the log if it doesn't exist\n if !File.exist? File.dirname(filename)\n FileUtils.mkdir_p File.dirname(filename)\n end\n\n @log ||= Logger.new(filename, rotation, max_size)\n @log.level = level\n @log\n end",
"def logger\n if @logger.nil?\n @logger = Logger::new(STDOUT)\n \n # formatter\n default = Logger::Formatter::new\n @logger.formatter = proc do |severity, datetime, progname, msg|\n progname = @targets.from\n msg = \"##{Thread.current.object_id} \" + msg \n default.call(severity, datetime, progname, msg)\n end\n end\n \n return @logger\n end",
"def logger\n init unless @initialized\n logger = @logger\n end",
"def initLogger()\n\tconfig = FileUtil.loadjson(File.dirname(__FILE__) + '/utilcfg.json')\n\tif config.key?('log.path')\n\t\tlpath = config['log.path']\n\t\tunless File.file?(lpath)\n\t\t\tdpath = lpath.gsub(/[^\\/]+$/,'')\n\t\t\tDir.mkdir(dpath) unless Dir.exist?(dpath)\n\t\tend\n\t\tif config.key?('log.interval')\n\t\t\t$logger = Logger.new(lpath, config['log.interval'])\n\t\telse\n\t\t\t$logger = Logger.new(lpath)\n\t\tend\n\tend\n\tLogUtil.setformatter\n\tLogUtil.setloglevel(config['log.level'])\nend",
"def new\n @log = Log.new\n end",
"def named(name)\n new_name = self.progname.to_s.dup\n new_name << \".\" unless new_name.empty?\n new_name << name\n new_logger = Logger.new(*@base_args)\n [:level, :formatter, :datetime_format].each do |m|\n new_logger.send(\"#{m}=\", self.send(m))\n end\n new_logger.progname = new_name\n new_logger\n end",
"def with_prefix (string)\n Logger.send(:new, string)\n end",
"def log\n return @logger if @logger\n @logger = Logger.new(LogFile)\n @logger.level = Logger::INFO\n @logger\n end",
"def init_logger\n l = Logger.new(STDOUT)\n l.level = Logger::INFO\n Log.logger = l\nend",
"def logger_func()\n\t########TO DO########\n# logging configuration\n# logger = Logger.new(STDOUT)\n# log_file = File.open(\"/Users/rubenalberto/Desktop/my-output.log\", \"a\")\n# logger = Logger.new(TeeRb::IODelegate.new(log_file, STDOUT))\n#logger = Logger.new(log_file)\nend",
"def configure_logger_for(classname)\n # handle case in which log path does not exists\n begin\n logger = Logger.new(@log_path)\n rescue Errno::ENOENT\n FileUtils.mkdir_p File.dirname @log_path\n retry\n end\n\n logger.progname = classname\n logger.level = @level\n logger.formatter = proc { |severity, datetime, progname, msg|\n case severity\n when 'DEBUG'\n spaciator = \" *\"\n after_space = \"\"\n when 'INFO'\n spaciator = \" **\"\n after_space = \" \"\n when 'WARN'\n spaciator = \" ***\"\n after_space = \" \"\n when 'ERROR'\n spaciator = \" ****\"\n after_space = \"\"\n when 'FATAL'\n spaciator = \"*****\"\n after_space = \"\"\n else\n spaciator = \" \"\n after_space = \"\"\n end\n\n formatted_output = \" #{spaciator} [#{severity}]#{after_space} [#{datetime}] -- #{msg} { #{progname} }\\n\"\n formatted_output\n }\n logger\n end",
"def logger\n raise NotImplementedError\n end",
"def logger(log_level = Logger::ERROR,log_file = nil)\n if log_file.nil?\n @log = Logger.new(STDOUT)\n else\n @log = Logger.new(log_file)\n end\n @log.level = log_level\n @log.formatter = proc { |severity, datetime, progname, msg|\n \"[#{datetime.strftime(\"%Y-%m-%d %H:%M:%S\")}] #{severity}: #{msg}\\n\"\n }\n end",
"def init_logger\n log = Log4r::Logger.new(STANDARD_LOGGER)\n log.trunc = true\n\n # sanity checks since we defined log4r's dynamic levels statically\n unless (Log4r::DEBUG == DEBUG) &&\n (Log4r::INFO == INFO) &&\n (Log4r::WARN == WARN) &&\n (Log4r::ERROR == ERROR) &&\n (Log4r::FATAL == FATAL)\n raise \"Logger levels do not match Log4r levels, levels may have been customized\"\n end\n\n Log4r::Logger[STANDARD_LOGGER].level = ERROR\n Log4r::Logger[STANDARD_LOGGER].trace = true\n\n Log4r::StderrOutputter.new :console\n Log4r::Outputter[:console].formatter = Log4r::PatternFormatter.new(:pattern => \"[%l] %m\")\n log.add(:console)\n end",
"def create_log(param); end",
"def _logger\n @logger ||= Log4r::Logger.new(self.class.to_s)\n end",
"def init_logger \n if not Object.const_defined?(get_rails_default_logger_name)\n Logger.new(STDOUT)\n else\n eval(get_rails_default_logger_name)\n end \n end",
"def logger\n @logger ||=\n begin\n logger = SemanticLogger::Processor.logger.clone\n logger.name = self.class.name\n logger\n end\n end",
"def initialize(log_level = 'debug')\n @logger = Logger.new(STDOUT, level: log_level)\n end",
"def logger!(_output)\n @logger = Logger.new(_output)\n end",
"def initialize\n @logger = Logging::Logger[self]\n end",
"def logger\n @logger ||= NilLogger.new\n end",
"def initialize_log(log)\n close if @log # be sure that we don't leave open files laying around.\n\n if log.respond_to?(:write)\n @log = log\n elsif File.exist?(log)\n @log = open(log, (File::WRONLY | File::APPEND))\n @log.sync = true\n else\n FileUtils.mkdir_p(File.dirname(log)) unless File.directory?(File.dirname(log))\n @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))\n @log.sync = true\n @log.write(\"#{Time.now.httpdate} #{delimiter} info #{delimiter} Logfile created\\n\")\n end\n end",
"def logger\n ::Logger.new($stdout).tap do |log|\n log.formatter = proc do |severity, _datetime, _progname, msg|\n prep = ' ' * (severity.size + 3)\n message = msg.lines.map.with_index do |str, i|\n next str if i.zero?\n\n str.strip.empty? ? str : prep + str\n end\n color = severity.downcase.to_sym\n msg = +\"[#{SeccompTools::Util.colorize(severity, t: color)}] #{message.join}\"\n msg << \"\\n\" unless msg.end_with?(\"\\n\")\n msg\n end\n end\n end",
"def logger\n @_logger ||= Logger.new(self)\n end",
"def start_logger\n if config && config[:log] == \"file\" && config.log_file_path\n start_file_logger(config.log_file_path)\n else\n start_stdout_logger\n end\n\n logger.level =\n if config\n config.log_level\n else\n Appsignal::Config::DEFAULT_LOG_LEVEL\n end\n logger << @in_memory_log.string if @in_memory_log\n end",
"def create_log_dir(log_dir, time_tag, metadata = Hash.new)\n end",
"def logger\n @logger ||= default_logger\n end",
"def logger(method_name)\n LoggingWrapper.new(\"#{self.class.name}.#{method_name}\")\n end",
"def create_child_logger(child_name)\n # add child_prefix + child_id\n instance_name = [\n @options[:_instance], self.class.child_prefix, child_name\n ].compact.join(self.class.separator)\n\n self.class.new(*@args, @options.merge(_instance: instance_name))\n end",
"def initialize(logdev, shift_age=0, shift_size=0)\n @default_shift_age = shift_age\n @default_shift_size = shift_size\n target = ::Logger.new(logdev, shift_age, shift_size)\n target.formatter = DEFAULT_FORMATTER\n @targets = [target]\n end",
"def logger\n @logger ||= begin\n l = ::Logger.new logfile\n l.level = loglevel\n l.progname = \"EM::AWS\"\n l\n end\n end",
"def logger\n if @logger.nil?\n @logger = Logger.new($stdout)\n @logger.level = Logger::WARN\n @logger.formatter = proc do |severity, datetime, m_progname, msg|\n \"[#{datetime.strftime('%F %H:%M:%S')} #{severity.red}] #{msg}\\n\"\n end\n end\n @logger\n end",
"def initialize(*logger_args)\n if logger_args.empty?\n logger_args = [$stderr]\n end\n @base_args = logger_args\n @logger = ::Logger.new(*@base_args)\n @logger.level = :fatal\n @lock = Mutex.new\n end",
"def configure_logger_for(name)\n logger = Logger.new(@logdev, @shift_age, @shift_size)\n logger.level = @level\n logger.progname = name\n logger.formatter = formatter\n logger\n end",
"def logger\n @logger ||= default_logger\n end",
"def creating( msg )\n @log.info \"creating #{msg}\"\n end",
"def new_instance_logger(suite, platform, index)\n name = instance_name(suite, platform)\n log_location = File.join(log_root, \"#{name}.log\").to_s\n Logger.new(\n stdout: STDOUT,\n color: Color::COLORS[index % Color::COLORS.size].to_sym,\n logdev: log_location,\n level: Util.to_logger_level(log_level),\n log_overwrite: log_overwrite,\n progname: name,\n colorize: @colorize\n )\n end",
"def init_logging\n app_name = ENV[\"APP_NAME\"] || \"calcentral\"\n format = PatternFormatter.new(:pattern => \"[%d] [%l] [CalCentral] %m\")\n\n Rails.logger = Log4r::Logger.new(app_name)\n Rails.logger.level = DEBUG\n Rails.logger.outputters = init_file_loggers(app_name, format)\n\n stdout = Outputter.stdout #controlled by Settings.logger.level\n stdout.formatter = format\n # level has to be set in the logger initializer, after Settings const is initialized.\n # see initializers/logging.rb\n Rails.logger.outputters << stdout\n end",
"def logger\n\t\t\tunless CLILogging.class_variable_defined?(:@@logger)\n\t\t\t\t@@logger = CLILogger.new\n\t\t\t\t@@logger.progname=$0\n\t\t\tend\n\t\t\t@@logger\n\t\tend",
"def logger\n\t\t\tunless CLILogging.class_variable_defined?(:@@logger)\n\t\t\t\t@@logger = CLILogger.new\n\t\t\t\t@@logger.progname=$0\n\t\t\tend\n\t\t\t@@logger\n\t\tend",
"def new_tagged_logger\n TaggedLoggerProxy.new server.logger,\n tags: server.config.log_tags.map { |tag| tag.respond_to?(:call) ? tag.call(request) : tag.to_s.camelize }\n end",
"def logger\n @logger ||= LogAdapter.new(Stevenson.new, (ENV[\"DAODAO_LOG_LEVEL\"] || :info).to_sym)\n end",
"def logger\n classname = self.class.name\n methodname = caller[0][/`([^']*)'/, 1]\n\n @_logger ||= ProjectHanlon::Logging.logger_for(classname, methodname)\n @_logger.progname = \"#{caller[0]}>>#{classname}\\##{methodname}\"\n @_logger\n end",
"def logger\n @logger ||= Logger.new(self)\n end",
"def initialize(*, verbose: '1', log_file: STDERR, **)\n v = (verbose =~ /\\d+/) ? verbose.to_i : verbose.to_sym\n self.logger = Logger.new(log_file, v)\n end",
"def setup_logger(logger = nil)\n # If a logger is specified we replace the existing.\n @logger = logger\n\n # Otherwise we create a new one.\n logger = Logger.new(STDOUT)\n logger.level = Logger::DEBUG\n @logger ||= logger\n end"
] |
[
"0.7998339",
"0.7998339",
"0.7969774",
"0.78619343",
"0.7503952",
"0.74591607",
"0.7391643",
"0.730702",
"0.7250956",
"0.72279227",
"0.70957506",
"0.7012958",
"0.7012958",
"0.69630843",
"0.69525987",
"0.68740416",
"0.68737173",
"0.6858736",
"0.68555224",
"0.6845333",
"0.6834957",
"0.68243873",
"0.6822892",
"0.6822892",
"0.68181235",
"0.68181235",
"0.677761",
"0.66981035",
"0.6694884",
"0.6691183",
"0.6570123",
"0.6566646",
"0.653531",
"0.65273976",
"0.65038747",
"0.64712644",
"0.64673066",
"0.6460876",
"0.64596057",
"0.6443426",
"0.643835",
"0.64255416",
"0.64103156",
"0.64103156",
"0.6397923",
"0.6395645",
"0.6395645",
"0.6395645",
"0.63823676",
"0.6372246",
"0.6366663",
"0.6333959",
"0.63204396",
"0.6312156",
"0.62894225",
"0.62693226",
"0.62643707",
"0.62632084",
"0.62499046",
"0.62358505",
"0.62302166",
"0.6227629",
"0.6206423",
"0.6205702",
"0.6205546",
"0.6201036",
"0.6197823",
"0.618946",
"0.6185552",
"0.61798066",
"0.61723185",
"0.61639786",
"0.615959",
"0.61563945",
"0.6148853",
"0.61428106",
"0.6141479",
"0.61161613",
"0.61157614",
"0.61089313",
"0.6103273",
"0.60863656",
"0.6072396",
"0.60662603",
"0.60590386",
"0.6051752",
"0.6044905",
"0.604159",
"0.60349464",
"0.6022761",
"0.60202676",
"0.6017266",
"0.6012225",
"0.6011837",
"0.6011837",
"0.60113955",
"0.60004544",
"0.5989122",
"0.59844106",
"0.5979752",
"0.5975975"
] |
0.0
|
-1
|
Changes the debug level to DEBUG if $DEBUG is set and writes a debugging message.
|
def debug(*args)
self.level = DEBUG if $DEBUG
super
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def debug message; write DEBUG, message, caller[0] unless level > @level end",
"def debug(msg=nil)\n log \"DEBUG: #{msg}\" if $debug\n end",
"def debug(message)\n $stdout.puts \"D #{message}\" if @debug\n end",
"def debug(message)\n puts message if debug?\n end",
"def debug(message)\n ostream.puts message if $DEBUG\n end",
"def debug(message)\n stdout.print(\"#{message}\\n\") if ENV['DEBUG']\n end",
"def debug!\n self.severity = :DEBUG\n end",
"def debug_msg(msg=\"\")\n if(@config.debug)\n puts(\"Debug: #{msg}\")\n @file.puts(\"Debug: #{msg}\")\n end\n end",
"def debug(msg)\n STDERR.puts msg if @debug\n end",
"def puts_debug(msg)\r\n if (self.debug) \r\n puts msg\r\n end # end debug\r\n end",
"def puts_debug(msg)\r\n if (self.debug) \r\n puts msg\r\n end # end debug\r\n end",
"def debug(msg)\n STDERR.puts msg if options.key? :debug\n end",
"def print_debug(msg)\n puts msg if (@debug) \n STDOUT.flush\n end",
"def debug_msg msg\n puts msg if @options[:debug]\n end",
"def debug_msg(msg)\n if(@options[:debug])\n @log.puts(msg)\n puts msg\n end\nend",
"def debug(message = \"\", level = 5)\n if $config[:global][:verboselevel] and $config[:global][:verboselevel] >= level\n puts message \n\t\t#logger.info(message)\n Syslog.info(message)\n end\nend",
"def debug(message)\n if DEBUG\n log message\n end\nend",
"def debug(msg)\r\n prelog\r\n logger.debug(msg)\r\n end",
"def say_debug(message)\n puts yellow(message) if self.debug\n end",
"def debug(msg)\n puts \"[watchr debug] #{msg}\" if options.debug\n end",
"def log_debug(message) # :nodoc:\n @logger.debug(message) if @logger\n end",
"def log_debug(debug_message)\n logger.debug(debug_message)\n end",
"def log_debug(debug_message)\n logger.debug(debug_message)\n end",
"def debug(msg)\n log(msg, level: Level::DEBUG)\n end",
"def debug(message)\n $stderr.puts(message) if @options[:debug]\nend",
"def debug(message)\n logger.debug(message) if logger\n end",
"def log(msg)\n puts(msg) if @info_values['enable_debug_logging'] == \"Yes\"\n end",
"def debug(message)\n log(0, message)\n end",
"def debug(msg); @logger.debug(msg); end",
"def debug=(new_debug)\n LOGGER.debug = new_debug\n end",
"def debug=(new_debug)\n LOGGER.debug = new_debug\n end",
"def debug(s) if $DEBUG then $stderr.print(\"#{s}\\n\") end end",
"def debug_on(debug=true)\n ap \"Debugging is ON\"\n @debug = debug\n end",
"def debug(message)\n return if quiet?\n say('[DEBUG] ' + message, :yellow) if $DEBUG\n end",
"def debug(message)\n puts \"#{Time.now.strftime(\"%H:%M:%S.%L\")} - \\t#{message}\" if DEBUG\nend",
"def debug\n Puppet::Util::Log.level = :debug\n end",
"def debug(message)\n warn \"==== VLO DEBUG: \" + message if ENV[\"VLO_DEBUG\"] == 'true'\nend",
"def debug(msg)\n $stderr.puts(\"DEBUG: #{msg}\") if $options['verbose']\nend",
"def debug(msg)\n $stderr.puts(\"DEBUG: #{msg}\") if $options['verbose']\nend",
"def debug(msg)\n $stderr.puts(\"DEBUG: #{msg}\") if $options['verbose']\nend",
"def debug(info)\n puts(info) if @debug\n end",
"def debug! \n $DEBUG = true\n end",
"def debug?; @level <= DEBUG; end",
"def debug?; @level <= DEBUG; end",
"def debug(message) ; @log.debug(message) ; end",
"def debug(log)\n output.puts log if log_level <= DEBUG\n end",
"def debug(msg)\n log.debug msg\n end",
"def debug(message)\n asl_log(@aslclient, @aslmsg, ASL_LEVEL_DEBUG, message)\n end",
"def dbg(msg, msgLevel = 1)\n\tif $options['debug'] >= msgLevel then\n\t\tputs \"#{msg}\"\n\tend\nend",
"def dbg(msg, msgLevel = 1)\n\tif $options['debug'] >= msgLevel then\n\t\tputs \"#{msg}\"\n\tend\nend",
"def debug(msg)\n @logger.debug(msg)\n end",
"def debug(msg)\n @logger.debug(msg)\n end",
"def debug(message = nil)\n log(:debug, message) unless message.nil?\n end",
"def debug(message, options = { })\n unless ENV['GUARD_ENV'] == 'test'\n reset_line if options[:reset]\n STDERR.puts color(\"DEBUG (#{Time.now.strftime('%T')}): \", :yellow) + message if ::Guard.options && ::Guard.options[:debug]\n end\n end",
"def debug string\n puts string if $DEBUG\nend",
"def debug(msg) #:doc:\r\n if have_hook?(:on_debug)\r\n sync { self.class.debug msg }\r\n end\r\n end",
"def debug(message, important = false)\n puts \"[DEBUG : #{Thread.current[:discordrb_name]} @ #{Time.now.strftime(LOG_TIMESTAMP_FORMAT)}] #{message}\" if @debug || important\n end",
"def debug_msg( str )\n puts str if @debug == true\n end",
"def debug msg\n if debug?\n return debug_writer.write msg if debug_writer.respond_to? :write\n return debug_writer.call(msg) if debug_writer.respond_to? :call\n raise \"No debug_writer set!\"\n end\n end",
"def log_debug(message)\n Rails.logger.debug message\n puts message\n end",
"def debug!\n @client.debug_dev = STDOUT\n end",
"def debug(msg) log(7, msg); end",
"def debug(message)\n logger.debug(PROG_NAME) { message }\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def setDebugLog(value)\n @fields['debug_log'] = value\n self\n end",
"def debug=(val)\n Handsoap::Service.logger = (val ? $stdout : nil)\n @@debug = val\n end",
"def debug?\n level <= DEBUG\n end",
"def debug_msg( *msg )\n\t\treturn unless $DEBUG\n\t\t$stderr.puts( *msg )\n\tend",
"def debug_msg( *msg )\n\t\treturn unless $DEBUG\n\t\t$stderr.puts( *msg )\n\tend",
"def log_debug(log_entry = \"\")\n entry(Gml::LOG_LEVEL_DEBUG, log_entry, 1)\n end",
"def log(msg)\n if ENV['LAUNCHY_DEBUG'] == 'true' then\n $stderr.puts \"LAUNCHY_DEBUG: #{msg}\"\n end\n end",
"def force_debug\n self.level = :debug\n @level_frozen = true\n end",
"def debug( msg=nil, &block )\n\t\t\t\tGemserver.logger.add( Logger::DEBUG, msg, @classname, &block )\n\t\t\tend",
"def debug_out(debmsg)\n if $gDebug\n puts debmsg\n end\n if ($gTest_params[\"logfile\"])\n $fLOG.write(debmsg)\n end\nend",
"def debug(message)\n return unless debugging?\n\n logger.debug(message.to_s)\n nil\n end",
"def debug_logging=(value)\n if value\n log.level = Logger::DEBUG\n elsif log.is_a?(Datadog::Logger)\n log.level = Logger::WARN\n end\n end",
"def debug(msg = \"\")\n puts \"\\n\\n\\n\"\n puts \" DEBUGGING \".white.on_red\n puts msg\n puts \"\\n\\n\\n\"\n exit\n end",
"def debug state=true\n @debug = state\n end",
"def debug message, opts = {}, &block\n log message, opts.merge(:debug => !opts[:log]), &block\n end",
"def vprint_debug(msg)\n print_debug(msg) if @verbose == true\n end",
"def debug(msg)\n end",
"def debug?\n level >= ASL_LEVEL_DEBUG\n end",
"def debug(str)\n $stderr.puts(str) if @debug\n end",
"def debug_out(debmsg)\n if $gDebug \n puts debmsg\n end\n if ($gTest_params[\"logfile\"])\n $fLOG.write(debmsg)\n end\nend",
"def debug(message = nil, progname = nil, &block)\n add(DEBUG, message, progname, &block)\n end",
"def debug(message)\n Manager::Base.debug(message)\n end",
"def toggle_debug!\n stream = @config[:debug]\n\n if stream.respond_to?(:<<)\n self.class.debug_output(stream)\n else\n self.class.debug_output\n end\n end",
"def debug?\n DEBUG == log_level\n end",
"def logDebug(message)\n found = false\n if ($logMessages)\n\tlogServer = get($serverPath+'log')\n\tif (logServer != nil)\n\t\tlogServer.debug(message)\n\t\tfound = true\n\tend\n end\n if (!found or !$logMessages or $printAllMessages)\n\tprint(message)\n end\n\nend",
"def debug\n logger.add(Logger::DEBUG, nil, facility) { yield } if logger && logger.debug?\n end",
"def debug(msg=nil)\n return unless msg\n (@logger ||= OMF::Common::LObject.new(self.class)).debug(msg)\n end",
"def debug(msg)\n @logProvider.debug(msg)\n end",
"def debug?\n severity == :DEBUG\n end",
"def debug (msg = \"\")\n if Object.const_defined?('Puppet')\n Puppet.debug msg\n else\n if ENV['FACTER_DEBUG'] == 'true'\n $stdout.puts msg\n $stdout.flush\n end\n end\nend",
"def debug(message, options = { })\n ::Guard::UI.debug(message, options)\n end"
] |
[
"0.76727146",
"0.7578764",
"0.7550893",
"0.7550796",
"0.754063",
"0.75295454",
"0.7517472",
"0.7489531",
"0.7460408",
"0.7451659",
"0.7451659",
"0.7442279",
"0.74192107",
"0.7381547",
"0.7360501",
"0.73530364",
"0.723405",
"0.71916807",
"0.7181005",
"0.7138657",
"0.7132161",
"0.70987177",
"0.70987177",
"0.709546",
"0.7085513",
"0.7073049",
"0.7062946",
"0.70623225",
"0.7050108",
"0.70405203",
"0.70405203",
"0.70173764",
"0.7003444",
"0.6999186",
"0.6995069",
"0.6967748",
"0.69676125",
"0.6961469",
"0.6961469",
"0.6961469",
"0.695772",
"0.69514835",
"0.6942772",
"0.6942772",
"0.6936166",
"0.6932671",
"0.693223",
"0.691939",
"0.6916219",
"0.6916219",
"0.6898023",
"0.6898023",
"0.6890598",
"0.6881804",
"0.6875166",
"0.6873493",
"0.68481445",
"0.6843694",
"0.68273294",
"0.68027353",
"0.6789714",
"0.6789342",
"0.6788908",
"0.67846",
"0.67846",
"0.67846",
"0.67846",
"0.67846",
"0.67846",
"0.67846",
"0.6768956",
"0.6749343",
"0.6746689",
"0.6746689",
"0.67420346",
"0.67289513",
"0.6727927",
"0.67234874",
"0.6684075",
"0.66832036",
"0.66760695",
"0.66714245",
"0.6670648",
"0.6663819",
"0.6663813",
"0.66506064",
"0.6642867",
"0.66250026",
"0.6613486",
"0.65995884",
"0.65966487",
"0.6596063",
"0.6591581",
"0.658492",
"0.65836227",
"0.65810215",
"0.6579462",
"0.65783316",
"0.65676004",
"0.65576667"
] |
0.7191312
|
18
|
Remembers when a warning occurs and writes a warning message.
|
def warn(*args)
self.warned = true
super
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def warning(message)\n write_message message, 'warning'\n end",
"def warning(msg)\n @warnings << msg\n owarn @warnings.last\n end",
"def warn(message)\n output[:warnings] << message\n end",
"def warn(msg)\n $warnings << msg if $warnings\nend",
"def warning\n state(\"warning\")\n end",
"def warn(message)\n self.warnings << message\n puts \"warn #{message}\"\n end",
"def warning(message)\n @warnings = [] unless @warnings.present?\n @warnings.append(message)\n end",
"def warning_ln(message)\n write_message message, 'warning', true\n end",
"def warning(warning)\n end",
"def warning!\n self.severity = :WARNING\n end",
"def warning(msg) $stderr.puts(\"Warning: #{msg}\") end",
"def warning(msg) $stderr.puts(\"Warning: #{msg}\") end",
"def warning(msg) $stderr.puts(\"Warning: #{msg}\") end",
"def warn(msg)\n puts \"WARNING: #{msg}\"\n end",
"def warning(msg) log(4, msg); end",
"def warning(message)\n log.warn(message.to_s.yellow)\n end",
"def warn(msg)\n #This is a stub, used for indexing\n end",
"def warning(msg)\n banner(\"Warning: #{msg}\", YELLOW)\n end",
"def warn message\n message = \"WARN: \" + process_message(message)\n output_message message, @warn_color if valid_conditions 2\n end",
"def warning(text)\n GitPusshuTen::Log.warning(text)\n end",
"def warn message; write WARN, message, caller[0] unless level > @level end",
"def warning(type, message, lineno)\n end",
"def warning(string); end",
"def warning(string); end",
"def warning(*args); end",
"def warn=(value) @warn = true; end",
"def warning=(value)\n @warning = value\n end",
"def warn\n\n end",
"def warning(text); end",
"def warning(text); end",
"def warn(msg)\n stderr \"warning: #{msg}\"\n end",
"def warn(message)\n log(2, message)\n end",
"def warn(check)\n update_check_status(check, 'warn')\n end",
"def deprecation_warning(key, warning)\n $_deprecation_warnings ||= {}\n unless $_deprecation_warnings[key]\n $_deprecation_warnings[key] = true\n Logger.logger.warn(warning)\n end\n end",
"def warn( msg )\n @stringio.puts msg\n end",
"def warn message\n @options.warn make_message message\n end",
"def on_warning(&f)\n @on_warning = f\n end",
"def warn(string)\n @has_warnings = true\n to_console loggify(string, :warning, :yellow), true\n to_file loggify(string, :warning)\n end",
"def warning?; end",
"def warning?; end",
"def warning?; end",
"def warn( msg )\n Kernel.warn( msg )\n end",
"def log_warning(message)\n log(message, DebugType::WARNING)\n end",
"def warn(msg); @logger.warn(msg); end",
"def warn(p0) end",
"def print_warning(msg)\n tag = '[ WARNING ]'\n print_formatted(tag,msg)\n end",
"def opoo(warning)\n # $stderr.puts \"#{Tty.yellow}Warning#{Tty.reset}: #{warning}\"\n warn \"#{Tty.yellow}Warning#{Tty.reset}: #{warning}\"\n end",
"def warn(message)\n log(\"#{color(\"WARNING:\", :yellow, :bold)} #{message}\")\n end",
"def warning(text)\n STDERR.puts yellow_term_text(text)\n end",
"def warn message\n log Logger::WARN, message\n end",
"def warning text\n print_red(\"WARNING: #{text}\") \n end",
"def warning text\n print_red(\"WARNING: #{text}\") \n end",
"def parse_warn(msg); say :warn, msg; end",
"def warning! opts = nil\n NOCH.evaluate_for \"warning\", opts\n end",
"def warn(message = nil, progname = nil, &block)\n add(WARN, message, progname, &block)\n end",
"def report_warn(type, message)\n @report.warn(type, message)\n end",
"def lwarn; end",
"def warn(message)\n asl_log(@aslclient, @aslmsg, ASL_LEVEL_WARNING, message)\n end",
"def warn(msg)\n log.warn msg\n end",
"def warn(msg)\n Chef::Log.warn(msg)\n end",
"def warnings; end",
"def warnings; end",
"def warnings; end",
"def warnings; end",
"def warnings; end",
"def warnings; end",
"def warnings; end",
"def warnings; end",
"def warn(filename, line, column_or_message, message = nil)\n return if !@@allow_double_warnings && @seen.add?([filename, line]).nil?\n if message\n column = column_or_message\n else\n message = column_or_message\n end\n\n location = \"line #{line}\"\n location << \", column #{column}\" if column\n location << \" of #{filename}\" if filename\n\n Sass::Util.sass_warn(\"DEPRECATION WARNING on #{location}:\\n#{message}\")\n end",
"def warn(message)\n err(\"#{color('WARNING:', :yellow, :bold)} #{message}\")\n end",
"def logWarning(message)\n found = false\n if ($logMessages)\n\tlogServer = get($serverPath+'log')\n\tif (logServer != nil)\n\t\tlogServer.warning(message)\n\t\tfound = true\n\tend\n end\n if (!found or !$logMessages or $printAllMessages)\n\tprint(message)\n end\n\nend",
"def warn string\n $log.warn string\n Ncurses.beep\n end",
"def alert_warning(statement, question=nil)\n @errs.puts \"WARNING: #{statement}\"\n ask(question) if question\n end",
"def warn(msg)\r\n logger.warn(msg)\r\n end",
"def licensing_warning(message)\n log.warn(log_key) { message }\n end",
"def warn(*args); end",
"def warn(*args); end",
"def warn(message)\n logger.warn(PROG_NAME) { message }\n end",
"def warn(m)\n log_handler.warn msg(m)\n end",
"def report_warn(type, message)\n @report.warn(type, message)\n Salus::PluginManager.send_event(:report_warn, { type: type, message: message })\n if @builds\n scanner = @report.scanner_name\n message = \"#{scanner} warning: #{type}, #{message}, build: #{@builds}\"\n end\n bugsnag_notify(message)\n end",
"def alert_warning(statement, question = nil)\n ui.alert_warning statement, question\n end",
"def warning(string)\n delegate.warning(path, self, string) if delegate.respond_to?(:warning)\n end",
"def warn?; @level <= WARN; end",
"def warn?; @level <= WARN; end",
"def warning(&block)\n begin\n update_status(:warning) if instance_eval(&block)\n rescue Exception\n update_status(:warning)\n end\n end",
"def warn_out(msg)\n if $gWarn\n puts \"\\n\\n WARNING: #{msg}\\n\\n\"\n end\n if ($gTest_params[\"logfile\"])\n $fLOG.write(\"\\n\\n WARNING: #{msg}\\n\\n\")\n end\n\n $gWarnings << msg.gsub(/\\n/,'')\n\nend",
"def warn!(message) #:doc:\n # TODO: log\n nil\n end",
"def warned; end",
"def log_warning warning\n message = '[aws-sdk-gem-warning] ' + warning\n if config.logger\n config.logger.warn(message)\n else\n $stderr.puts(message)\n end\n nil\n end",
"def lwarn\n logger.add(Logger::WARN, nil, facility) { yield } if logger && logger.warn?\n end",
"def warn(topic, message = nil, &block)\n write(:warn, topic, message, &block)\n end",
"def licensing_warning(message)\n licensing_warnings << message\n log.warn(log_key) { message }\n end",
"def warning(warning_message, *args)\n STDERR.puts(\"#{warning_message} - #{args.join(',')}\")\n end",
"def warning(warning_message, *args)\n STDERR.puts(\"#{warning_message} - #{args.join(',')}\")\n end",
"def emit_warning(collector, current_node, message)\n if collector and collector.respond_to? :add_warning\n collector.add_warning(message)\n end\n if collector and collector.respond_to? :add_debug\n collector.add_debug(current_node.to_s, message)\n end\n end",
"def warn(msg)\n log(msg, level: Level::WARN)\n end",
"def Warning(warning_string)\n Builtins.y2warning(1, \"%1\", warning_string) if @log_warnings\n\n if @display_warnings\n if Ops.greater_than(@timeout_warnings, 0)\n Popup.TimedWarning(warning_string, @timeout_warnings)\n else\n Popup.Warning(warning_string)\n end\n end\n\n @warnings = Builtins.add(@warnings, warning_string)\n\n nil\n end",
"def deprecation_warning\n if this_blog.deprecation_warning != 42\n Blog.transaction do\n this_blog.deprecation_warning = 42\n this_blog.save\n end\n flash[:error] = \"Deprecation warning: please, notice that most plugins have been removed from the main engine in this new version. To download them, run <code>script/plugins install myplugin</code>, where myplugin is one of them at http://svn.typosphere.org/typo/plugins/\"\n end\n end",
"def log_warn(warn_message)\n logger.warn(warn_message)\n end",
"def warn(topic, message = T.unsafe(nil), &block); end"
] |
[
"0.77955663",
"0.7786037",
"0.7666773",
"0.7564739",
"0.7452888",
"0.74487823",
"0.73752314",
"0.7362536",
"0.73564875",
"0.7344176",
"0.7338517",
"0.7338517",
"0.7338517",
"0.72915035",
"0.7178832",
"0.7129849",
"0.7101731",
"0.7099894",
"0.7068309",
"0.70676357",
"0.7067214",
"0.7061267",
"0.7058898",
"0.7058898",
"0.7043321",
"0.703154",
"0.699337",
"0.69890803",
"0.69716614",
"0.69716614",
"0.69667363",
"0.69363207",
"0.69283026",
"0.69219714",
"0.69001025",
"0.68728894",
"0.68609685",
"0.6858746",
"0.68550867",
"0.68550867",
"0.68550867",
"0.68519366",
"0.6846532",
"0.68081164",
"0.68080044",
"0.6801577",
"0.6788376",
"0.6781088",
"0.677998",
"0.6752294",
"0.6746942",
"0.6746942",
"0.672374",
"0.67111945",
"0.6706717",
"0.6686525",
"0.6682566",
"0.6679306",
"0.667573",
"0.66744846",
"0.6664885",
"0.6664885",
"0.6664885",
"0.6664885",
"0.6664885",
"0.6664885",
"0.6664885",
"0.6664885",
"0.66448694",
"0.6643894",
"0.6620713",
"0.6611013",
"0.66103584",
"0.6610104",
"0.654498",
"0.65297097",
"0.65297097",
"0.6528239",
"0.6527849",
"0.651258",
"0.6510233",
"0.6501598",
"0.6498946",
"0.6498946",
"0.6496235",
"0.6485233",
"0.6482949",
"0.64704484",
"0.64692014",
"0.6459732",
"0.6454978",
"0.64400846",
"0.6436379",
"0.6436379",
"0.64287895",
"0.64261246",
"0.64166856",
"0.6415617",
"0.64079833",
"0.6401729"
] |
0.66540354
|
68
|
Displays a progress indicator for a given message. This progress report is only displayed on TTY displays, otherwise the message is passed to the +nontty_log+ level.
|
def progress(msg, nontty_log = :debug)
send(nontty_log, msg) if nontty_log
return unless show_progress
icon = ""
if defined?(::Encoding)
icon = PROGRESS_INDICATORS[@progress_indicator] + " "
end
@mutex.synchronize do
print("\e[2K\e[?25l\e[1m#{icon}#{msg}\e[0m\r")
@progress_msg = msg
if Time.now - @progress_last_update > 0.2
@progress_indicator += 1
@progress_indicator %= PROGRESS_INDICATORS.size
@progress_last_update = Time.now
end
end
Thread.new do
sleep(0.05)
progress(msg + ".", nil) if @progress_msg == msg
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def progress(msg, nontty_log = T.unsafe(nil)); end",
"def report_progress(message)\n @progress_block.call(message) if @progress_block\n end",
"def ReportProgress(progress_s)\n progress_s = Builtins.sformat(\"=== %1 ===\", progress_s)\n\n Builtins.y2milestone(\"%1\", progress_s)\n UI.ChangeWidget(\n Id(:log_view),\n :LastLine,\n Ops.add(Ops.add(\"\\n\", progress_s), \"\\n\")\n )\n\n nil\n end",
"def log(message)\n\t\tif !@progress_dialog.nil?\n\t\t\t@progress_dialog.logMessage(message)\n\t\telse\n\t\t\tputs message\n\t\tend\n\tend",
"def report_progress(progress, total, show_parts=true)\n if total && total > 0\n percent = (progress.to_f / total.to_f) * 100\n line = \"Progress: #{percent.to_i}%\"\n line << \" (#{progress} / #{total})\" if show_parts\n else\n line = \"Progress: #{progress}\"\n end\n\n info(line, :new_line => false)\n end",
"def progress_bar(progress_ratio)\n max = @screen_size * 0.8\n print \"\\r\\t[#{progress_ratio.round(2)*100}%] [\"\n print \"#\".magenta * (progress_ratio * max)\n print \"] DONE!\\n\" if progress_ratio == 1\n end",
"def print_status_message text=$status_message\n r = $status_message_row || Ncurses.LINES-1\n clear_error r, $datacolor\n # print it in centre\n printstring r, (Ncurses.COLS-text.length)/2, text, color = $promptcolor\n end",
"def write(msg)\n if msg.end_with?(\"\\n\")\n @progress_bar.clear\n if @current_line.nil?\n # New messages to be displayed\n @stream << msg\n else\n # Ending previous line\n @stream << (@current_line + msg)\n @current_line = nil\n end\n @progress_bar.refresh(force: true) unless @progress_bar.stopped?\n elsif @current_line.nil?\n # Beginning new line\n @current_line = msg\n else\n # Continuing current line\n @current_line << msg\n end\n end",
"def show_progress=(_arg0); end",
"def print_status(msg)\n puts \"\" if verbose_mode?\n puts \"#{color('----->', 32)} #{msg}\"\n end",
"def minimal_progress_callback(state)\n case state\n when :start then print '|'\n when :step then print '.'\n when :end then puts\n end\n\n $stdout.flush\n end",
"def sample_progress_bar\n\trequire_relative 'lib/console'\n\t\n\tprogress = Console.logger.progress(\"Progress Bar\", 10)\n\t\n\t10.times do |i|\n\t\tsleep 1\n\t\t\n\t\tprogress.increment\n\tend\nend",
"def statusbar(message, time=nil)\n message << \" (#{time.round(3)}s)\" if time\n message = message.to_s.center term_width\n block_given? ? yield(message) : message\n end",
"def print_progress_bar_at i\n if (i%PROGRESSOR_SAMPLE_PERIOD == 0)\n print '.'\n $stdout.flush\n end\nend",
"def step_status(msg = '')\n\t\toutput.print_status(\"#{pos}: #{msg}\") if (msg and msg.length > 0)\n\tend",
"def status_message\n (+'').tap do |ret|\n if task.progress\n ret << \"#{(task.progress * 100).to_i}%\"\n ret << ': ' if task.progress_message.present?\n end\n ret << task.progress_message if task.progress_message.present?\n end\n end",
"def print_status(msg = '')\n $stderr.puts \"[*] #{msg}\"\n end",
"def describe_progress\n if @options[:num]\n \"#{@messages.size} of #{@options[:num]} message#{'s' if @messages.size!=1} collected\"\n else\n \"#{@messages.size} message#{'s' if @messages.size!=1} collected\"\n end \n end",
"def status(msg = '')\n\t\toutput.print_status(msg)\n\tend",
"def indicate_progress\n end",
"def progress(size, file)\n\t\tprint '.'\n\t\tsleep 1.5\n\t\tprint '.'\n\t\tsleep 1.5\n\t\tprint '.'\n\t\tsleep 1.5\n\t\tpercent = (File.size? file).to_f / size.to_f\n\t\tpercent = percent * 100\n\t\tpercent = ((percent*20).round / 20.0)\n\t\tprint \"\\e[1;37m#{percent}\\e[0m%\"\n\tend",
"def show_progress\n\t\t\t# bar_size is between 0 and 30\n finish_size = (((@top_card-12).to_f / (@deck.length-11).to_f) * 30).to_i\n\t\t\tremain_size = 30 - finish_size\n\t\t\tprint \"\\nProgress: \"\n\t\t\tfinish_size.times {print '▓'}\n\t\t\tremain_size.times {print '░'}\n\t\t\tputs\n\t\t\tputs\n end",
"def msg(message)\n stdout.puts message\n end",
"def progress(percentage, description = nil)\n reply({:progress => percentage, :description => description}, {:message_type => 'progress'})\n end",
"def report_progress(data = {})\n @progress_count ||= 0\n\n if (@progress_count += 1) > 4\n warn(\"do not call Slackathon::Command#report_progress more than 4 times\")\n return\n end\n\n say(\n response_type: :ephemeral,\n text: format(progress_message, data)\n )\n end",
"def progress_info\n\n color=\"#AAAAAA\"\n progress=0\n message=\"Log not available.\"\n\n if self.cluster_stdout\n\n color=\"blue\"\n progress=0\n message=\"Execution not started.\"\n\n self.cluster_stdout.each_line do |line| \n if /\\([0-9]* run \\/ [0-9]* fail \\/ [0-9]* done \\/ [0-9]* left\\)/.match(line)\n run = /[0-9]* run/.match(line)[0].to_s.split[0].to_f \n done = /\\/ [0-9]* done/.match(line)[0].to_s.split[1].to_f\n failed = /\\/ [0-9]* fail/.match(line)[0].to_s.split[1].to_f\n left = /\\/ [0-9]* left/.match(line)[0].to_s.split[1].to_f\n progress=100*(run+done+failed)/(run+done+failed+left)\n # set toolbar color \n red=255*(failed)/(failed+done+run)\n blue=255*(run).to_f/(failed+done+run).to_f\n green=128*(done).to_f/(failed+done+run).to_f\n color=\"rgb(#{red.to_i},#{green.to_i},#{blue.to_i})\"\n if progress!= 100 && (\n\t CbrainTask::COMPLETED_STATUS.include?(self.status) ||\n\t CbrainTask::FAILED_STATUS.include?(self.status) ||\n\t self.status == \"Post Processing\" ||\n\t self.status == \"Data Ready\")\n color=\"red\"\n end\n if progress==100\n\t color=\"green\"\n end\n message=\"PSOM tasks: #{run.to_i} run / #{failed.to_i} fail / #{done.to_i} done / #{left.to_i} left\"\n end\n end\n end \n return {:color => color,:percentage => progress, :message => message, :show_percentage => true}\n end",
"def set_status(message, percentage)\n return false unless have_lock?\n @handle.rewind\n @handle.truncate 0\n @handle.write(message.to_s.strip + \"\\n\")\n @handle.write(percentage.to_s.strip + \"\\n\")\n @handle.flush\n true\n end",
"def print_status(msg, color)\n cprint RESET + BOLD\n cprint WHITE + \"[ \"\n cprint \"#{ msg } \", color\n cprint WHITE + \"] \" + RESET\n end",
"def print_status(msg, color)\n cprint RESET + BOLD\n cprint WHITE + \"[ \"\n cprint \"#{ msg } \", color\n cprint WHITE + \"] \" + RESET\n end",
"def print_status(msg)\n\t\tself.module.print_status(msg)\n\tend",
"def print_progress\n @data[\"print_progress\"]\n end",
"def run_with_progress(message, size, progr = nil, &block)\n if(progr_object = (progr || progressor))\n progr_object.run_with_progress(message, size, &block)\n else\n dummy_prog = Object.new\n class << dummy_prog\n def inc\n end\n end\n block.call(dummy_prog)\n end\n end",
"def ui_message(message)\n puts message\n end",
"def say_status(status, message, log_status = true)\n Strainer.log.info(\"status: #{status}, message: #{message}\")\n\n return if quiet?\n super(status, message, log_status)\n end",
"def message cmd, msg\n print_message cmd, 'INFO', msg\nend",
"def info_and_log(message)\n @ui.info(message)\n @logger.info(message)\n end",
"def msg(message)\n puts message unless nagios_mode?\n end",
"def user_message(msg, level=0, type=\"info\")\n if not(quiet_mode?)\n message(type, :green, \" \"*level + msg)\n end\n end",
"def info(msg)\n if Dotgpg.interactive?\n $stdout.puts msg\n end\n end",
"def progress_line; end",
"def clear_progress\n return unless show_progress\n print_no_newline(\"\\e[?25h\\e[2K\")\n @progress_msg = nil\n end",
"def print_progress(current, total, started_at)\n if total.nil?\n print_progress_nosize(current, started_at)\n return\n end\n ratio = [current.to_f / total, 1.0].min\n percent = (ratio * 100.0).round(1)\n arrow = (ratio * 20.0).floor\n time_spent = Time.now.to_i - started_at\n print(\"\\r[\")\n print('=' * [arrow - 1, 0].max)\n print('>')\n print('.' * (20 - arrow))\n print(\"] #{pretty_filesize(current)}/#{pretty_filesize(total)} (#{percent}% at #{pretty_filesize(current.to_f / time_spent)}/s) \")\n end",
"def show_progress\n\t\t@placeholder.join(\" \")\n\tend",
"def with_progress_bar(&block)\n return unless $stdout.tty?\n @progress_bar ||= ::ProgressBar.new\n block.call @progress_bar\n end",
"def puts_success(message, dir = nil)\n m = \"\\n[\\e[0;32m✔\\e[0m] #{message}\"\n m << \" (#{dir} - #{`du -md 0 #{dir}`.split(' ')[0]}M)\" if dir\n puts m << \"\\n\\n\"\nend",
"def set_progress_msg(word)\n @progress_message = (\"-\" * word.length)\n @progress_message\nend",
"def print_status(string)\n\tputs \"[*] \".light_blue + \"#{string}\".white\nend",
"def say_status(status, color)\n base.shell.say_status(status, path, color) if verbose?\n end",
"def status(text)\n STDERR.puts blue_term_text(text)\n end",
"def info(msg)\n if verbose?\n verbose_io << msg << \"\\n\"\n verbose_io.flush\n end\n end",
"def info(message)\n puts \"\\e[35m#{message}\\e[0m\"\n end",
"def display_progress\n\t\t@progress_key.join(\" \")\n\tend",
"def execute(input: $stdin, output: $stdout)\n prompt.ok('simple progress bar')\n\n bar = TTY::ProgressBar.new(\"downloading [:bar]\", total: 30)\n \n 30.times do\n sleep(0.1)\n bar.advance(1)\n end\n\n :gui\n end",
"def progress_output\n arr = @progress.map do |key, value|\n \"#{key}: #{value}\\n\"\n end\n arr.join('')\n end",
"def display_message!(*lines)\n display_message(*lines)\n sleep 0.01 until message_drawn?\n end",
"def progress(run)\n return unless run.started?\n\n progress = Progress.new(run)\n\n progress_bar = tag.progress(\n value: progress.value,\n max: progress.max,\n class: [\"progress\"] + STATUS_COLOURS.fetch(run.status)\n )\n progress_text = tag.p(tag.i(progress.text))\n tag.div(progress_bar + progress_text, class: \"block\")\n end",
"def start_progress(max_progress)\n @show_progress = true\n @max_progress = max_progress\n @progress = 0\n display\n end",
"def say_status(status, color)\n base.shell.say_status(status, dir, color) if verbose?\n end",
"def progress_bar(progress, options = {})\n opts = {\n :progress_color => \"#10E010\",\n :background_color => \"white\",\n :border_color => \"#AAAAAA\",\n :width => 100,\n :height => 22,\n :border_width => 2,\n :as => :fraction, # or :percentage\n :denominator => 5\n }.merge options\n\n text = nil\n if opts[:as] == :fraction\n text = (progress * opts[:denominator]).to_i.to_s + \"/#{opts[:denominator]}\"\n elsif opts[:as] == :percentage\n text = (progress * 100).to_i.to_s + \"%\"\n else\n text = progress\n end\n\n start = progress_bar_open(opts) + progress_bar_inner_open(progress, opts)\n if progress > 0.5\n start + (text || \" \").to_s + \"</span></div>\"\n else\n start + \" </span><span style=\\\"float:left;position:absolute;left:#{opts[:width]*progress}px;height:#{opts[:height]}px;width:#{opts[:width]*(1-progress)}px;text-align:center;\\\">\" + (text || \" \").to_s + \"</span></div>\"\n end\n end",
"def say(status, message = \"\", log_status = true)\n shell = Thor::Shell::Color.new\n log_status = false if @options and @options[:quiet]\n shell.say_status(status, message, log_status)\n end",
"def say(message)\n puts green(message) if self.verbose \n end",
"def to_s\n if @show_progress\n \"#{@message} (#{@progress} of #{@max_progress})\"\n else\n \"#{@message}\"\n end\n end",
"def print_game_progress(count)\n puts \"#{\".\" * 50}\"\n puts \"\\nWord : #{@incomplete_word}\"\n puts \"Attempts Left: #{@limit - count}\"\n unless @incorrect_guesses.empty?\n puts \"Incorrect inputs: #{@incorrect_guesses.join(\", \")}\"\n end\n puts \"#{\".\" * 50}\"\n end",
"def draw_status_text\n draw_text(0, 0, contents_width, line_height, status_text, 1)\n end",
"def message(input)\r\n start_line\r\n puts input.colorize(:light_blue)\r\n sleep(1.5)\r\n end",
"def info message\n message = \"INFO: \" + process_message(message)\n output_message message, @info_color if valid_conditions 1\n end",
"def say_status(message, status)\n message += '...'\n puts message + status.to_s.rjust((COLUMN_SIZE * COLUMN_NUM) - message.size)\nend",
"def update_gauge(gauge, percent, message)\n if Time.now - @last_ui_update_time > MIN_UI_UPDATE_INTERVAL || percent == 100\n @last_ui_update_time = Time.now\n gauge.puts 'XXX'\n gauge.puts percent\n gauge.puts message\n gauge.puts 'XXX'\n end\n end",
"def describe_progress\n str = \"#{identifier}: #{@title.capitalize} collection \"\n str << \"in response to #{@options[:m_id]} \" if @options[:m_id]\n str << \"didn't complete within #{@options[:timeout]}s, \"\n str << \"reached #{@messages.size}/#{@options[:num]}\"\n str\n end",
"def step(number_steps = 1)\n @current_progress+= number_steps\n if ((@current_progress - number_steps) / @steps_per_progress_bar_marker).to_i \\\n < (@current_progress / @steps_per_progress_bar_marker).to_i\n @marker_counter += 1\n putc '.' \n puts if @marker_counter == @bar_length # after the last marker is printed, add a new_line\n $stdout.flush\n end\n end",
"def message(msg)\n STDOUT.puts msg\n end",
"def step(step_increment = 1)\n @current_steps+= step_increment\n new_markers = @max_steps != 0 ? (@current_steps / @steps_per_marker).to_i : max_markers\n\n new_percentage = @max_steps != 0 ? @current_steps * 100 / @max_steps : 100\n if @use_ansi and new_percentage != @current_percentage\n # This part uses ANSI escape sequences to show a running percentage\n # to the left of the progress bar\n print \"\\e[1D\" * (@current_markers + 5) if @current_percentage != 0 # go left\n print \"#{new_percentage}%\".rjust(4) << \" \"\n print \"\\e[1C\" * @current_markers if @current_markers != 0 # go back right\n $stdout.flush rescue nil\n @current_percentage = new_percentage\n end\n\n if new_markers > @current_markers\n print '.' * (new_markers - @current_markers)\n @current_markers = new_markers\n $stdout.flush rescue nil\n end\n if @current_steps == @max_steps\n print '.' * (max_markers - @current_markers) + ' '\n $stdout.flush rescue nil\n end\n end",
"def info(message, level=:default)\n $stdout.puts colorize(message, level)\n end",
"def progress; end",
"def progress; end",
"def progress; end",
"def progress; end",
"def progress; end",
"def updated(message)\n @count += 1\n @out.print \".\"\n @out.flush\n end",
"def report_message(message, state)\n color = state == true ? :green : :red\n str = message.colorize(color)\n output_to_path(str)\n store(str, state)\n end",
"def display(msg)\n stdout.puts msg\n return \"#{msg}\\n\"\n end",
"def progress\n @progress.scan(/_|\\w/).join(' ')\n end",
"def info(message)\n puts(stdout, message)\n end",
"def console_message(msg)\n emit(status_message(msg.force_encoding('utf-8')))\n end",
"def update_progress(a)\n\t\tscript = 'update(\\''+a.to_s+'%\\');'\n\t\tputs script\n\t\t$dlgSplashScreen.execute_script( script )\n\t\t\n\t\tif (a==100)\n\t\t\t$dlgSplashScreen.close\n\t\t\tmenu\n\t\tend\n\tend",
"def debug(message)\n @progress = Time.now.to_f\n buffer_checkpoint(\"debug: #{message}\")\n end",
"def print_status(msg='')\n end",
"def progress_line=(_arg0); end",
"def use_progress_bar?; true end",
"def main_total_bar\n p = percent(money_used, incomes)\n if p < 100\n \"<div class='progress primary'><span class='meter' style='width: #{p}%'></span></div>\".html_safe\n elsif p > 100\n \"<div class='progress alert'><span class='meter' style='width: 100%'></span></div>\".html_safe\n else\n \"<div class='progress success'><span class='meter' style='width: 100%'></span></div>\".html_safe\n end\n end",
"def report_progress\n backup_size = (@backup.size + @backup.wal_file_size) / 1024 ** 2\n du = target_path_exists? ? target_path_disk_usage / 1024 ** 2 : 0\n percent = du.to_f / backup_size.to_f * 100\n percent = 100.0 if percent >= 100.0\n message = \"#{percent.to_i}% of Backup #{@backup.id} (#{@backup.server}) recovered\" \n at(percent.to_i, 100, message)\n @log.info(message)\n end",
"def show_progress(collection, say=\"Progress\", &block)\n progress_bar = ProgressBar.new say, collection.count\n\n collection.each do |thing|\n block.call thing\n progress_bar.increment\n end\n\n puts # distinguish progress_bar output from other output\nend",
"def updated(message)\n @count += 1\n @out.puts \"#{@count}/#{@total}: #{message}\"\n end",
"def indicate_progress\n @iteration_counter += 1\n @progress_rate ||= resolver_ui.progress_rate\n if iteration_rate.nil?\n if Time.now - started_at >= @progress_rate\n self.iteration_rate = @iteration_counter\n end\n end\n\n if iteration_rate && (@iteration_counter % iteration_rate) == 0\n resolver_ui.indicate_progress\n end\n end",
"def write_status(state, mesg = '')\n msg = \"#{state} #{mesg}\\n\"\n\n STDOUT.write(\"#{Process.pid} - #{Time.now} - #{msg}\")\n STDOUT.flush\n $RQ_IO.syswrite(msg)\nend",
"def _perform_notify(message, opts = {})\n first_line = message.sub(/^\\n/, \"\").sub(/\\n.*/m, \"\")\n\n STDOUT.puts \"\\e]2;[#{ opts[:title] }] #{ first_line }\\a\"\n end",
"def with_progress_bar(nbr_total, name: nil)\n previous_stdout_device = nil\n previous_stderr_device = nil\n progress_bar = nil\n LoggerHelpers.progress_bar_semaphore.synchronize do\n stdout_log_device = stdout_device\n progress_bar = ProgressBar.create(\n output: stdout_log_device.is_a?(ProgressBarLogDevice) ? $stdout : stdout_log_device,\n title: 'Initializing...',\n total: nbr_total,\n format: \"#{name ? \"#{name} \" : ''}[%j%%] - |%bC%i| - [ %t ]\",\n progress_mark: ' ',\n remainder_mark: '-'\n )\n if stdout_displayed? && !stdout_log_device.is_a?(ProgressBarLogDevice)\n # Change the current logger so that when its logdev calls write it redirects to our ProgressBar#log\n previous_stdout_device = stdout_device\n self.stdout_device = ProgressBarLogDevice.new(progress_bar, previous_stdout_device)\n end\n if stderr_displayed? && !stderr_device.is_a?(ProgressBarLogDevice)\n # Change the current logger so that when its logdev calls write it redirects to our ProgressBar#log\n previous_stderr_device = stderr_device\n self.stderr_device = ProgressBarLogDevice.new(progress_bar, previous_stderr_device)\n end\n end\n begin\n yield progress_bar\n ensure\n LoggerHelpers.progress_bar_semaphore.synchronize do\n stdout_device.flush\n stderr_device.flush\n self.stdout_device = previous_stdout_device unless previous_stdout_device.nil?\n self.stderr_device = previous_stderr_device unless previous_stderr_device.nil?\n end\n end\n end",
"def info(message)\n print(5, message)\n end",
"def text=(text)\n @progressBar.text = text.to_s\n end",
"def notify(message)\n status_bar = @builder['statusbar']\n status_bar.push(status_bar.get_context_id(''), message)\n end"
] |
[
"0.77027094",
"0.6517017",
"0.6432016",
"0.63986486",
"0.63013893",
"0.62673146",
"0.5994179",
"0.5977254",
"0.59584814",
"0.58779776",
"0.58413565",
"0.5832809",
"0.573447",
"0.57272077",
"0.57156104",
"0.57072085",
"0.56922144",
"0.5677506",
"0.5674355",
"0.5667573",
"0.5655366",
"0.5644961",
"0.55981",
"0.55843186",
"0.55841076",
"0.55792046",
"0.55701345",
"0.5549315",
"0.5549315",
"0.5545254",
"0.5540506",
"0.5530952",
"0.5526325",
"0.5497147",
"0.54846156",
"0.54809207",
"0.5478319",
"0.5471396",
"0.5446324",
"0.54135716",
"0.5413248",
"0.5395358",
"0.5395236",
"0.53929025",
"0.5388285",
"0.5388015",
"0.53755414",
"0.536966",
"0.53671515",
"0.5358231",
"0.534946",
"0.5339344",
"0.53333026",
"0.5324662",
"0.5301531",
"0.52916855",
"0.5288716",
"0.5280712",
"0.5272984",
"0.52723014",
"0.5271368",
"0.52529925",
"0.5231431",
"0.5230368",
"0.52301306",
"0.52285784",
"0.5228275",
"0.5227428",
"0.5221679",
"0.5221673",
"0.5219474",
"0.52086407",
"0.52047205",
"0.5181136",
"0.5181136",
"0.5181136",
"0.5181136",
"0.5181136",
"0.51681703",
"0.5162818",
"0.51575565",
"0.5157499",
"0.51551896",
"0.5140698",
"0.51392263",
"0.5134969",
"0.5130495",
"0.5127682",
"0.5118013",
"0.511715",
"0.51126254",
"0.51100785",
"0.5101692",
"0.50995564",
"0.5095101",
"0.50868666",
"0.5077228",
"0.5069097",
"0.50643486",
"0.50638497"
] |
0.8307875
|
0
|
Clears the progress indicator in the TTY display.
|
def clear_progress
return unless show_progress
print_no_newline("\e[?25h\e[2K")
@progress_msg = nil
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def clear_progress; end",
"def clear_output(wait=false)\n Display.clear_output(wait)\n end",
"def clear\n $stdout.print \"\\n\"\n $stdout.flush\n end",
"def clear\n Vedeu::Terminal.clear\n end",
"def clear_screen\n puts \"\\e[H\\e[2J\"\n end",
"def clear\n # If n is 2, clear entire screen (and moves cursor to upper left on DOS ANSI.SYS).\n print \"\\e[2J\\e[H\"\n end",
"def clear_screen\n CSI + '2J'\n end",
"def clear_screen!\n print \"\\e[2J\"\n end",
"def clear_screen\n output(Esc.string('clear'))\n end",
"def clear_stream\n @stream.print(' ' * IO.console.winsize[1])\n end",
"def clear_screen\r\n system('clear') || system('cls')\r\n end",
"def clear_screen\n\tputs \"\\e[2J\" \n print \"\\e[H\"\nend",
"def pause_and_clear_screen\n sleep(1.50)\n system('clear')\n end",
"def clear_display\n system('clear') || system('clc')\n end",
"def clear_all\n Terminal.move_up(previous_draw_amount_of_lines)\n Terminal.clear_screen_from_cursor\n end",
"def clear; puts \"\\e[2J\" end",
"def clear_screen\n\t\tputs \"Clearing screen\"\n\t\tsystem(CLEAR_COMMAND)\n\tend",
"def clear_stdout\n $stdout.string = ''\n end",
"def clean_screen\n sleep 1\n system 'clear'\n end",
"def reset\n STDOUT.write \"\\033[0m\"\n end",
"def clear_terminal\n system(\"cls\") || system(\"clear\")\nend",
"def clear_line!\n print \"\\r\\e[2K\"\n end",
"def clear_screen_down\n CSI + 'J'\n end",
"def clear_screen\n print \"\\e[2J\"\nend",
"def clear_line; print \"\\e[2K\" end",
"def clear_screen\n system \"clear\" or system \"cls\"\n end",
"def clear_screen\n system \"clear\" or system \"cls\"\n end",
"def clear_screen\n sleep(3)\n system \"clear\"\nend",
"def clear_screen\n print \"\\e[2J\"\nend",
"def clear_screen\n print \"\\e[2J\"\nend",
"def clear_screen\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\n puts\r\nend",
"def clear_screen\n 40.times { puts }\n end",
"def print_clear; print \"\\e[0J\" end",
"def clear_line\n puts \"\\e[0A\\e[0G\"\n end",
"def clear\n writeln(\"clear\")\n end",
"def clear\n say \"\\e[2J\\e[H\"\n end",
"def clear_screen\n print \"\\e[2J\\e[f\"\nend",
"def clear_screen_up\n CSI + '1J'\n end",
"def clear_frame\n print(\"\\e[1K\\e[G\")\n end",
"def clearScreen\n puts \"\\e[H\\e[2J\"\nend",
"def clear_screen\n system('clear') || system('cls')\nend",
"def clear_screen\n system('clear') || system('cls')\nend",
"def clearscreen\n system('cls')\nend",
"def clear_scr\n system 'clear'\n system 'cls'\n end",
"def clear_screen\n print @screen.to_s\n end",
"def clear_terminal\n RUBY_PLATFORM =~ /win32|win64|\\.NET|windows|cygwin|mingw32/i ? system('cls') : system('clear')\n end",
"def clear\n\n # remove the trailing newline, otherwise an upper line will get eaten\n @rendered.sub!(/\\n\\z/, '')\n\n # determine how many lines to move up\n lines = @rendered.scan(/\\n/).length\n\n if @bottomline\n print IOChar.cursor_down + IOChar.carriage_return + IOChar.clear_line + IOChar.cursor_up\n end\n\n # jump back to the first position and clear the line\n print IOChar.cursor_down + IOChar.carriage_return + IOChar.clear_line + IOChar.cursor_up + IOChar.clear_line + IOChar.carriage_return + ( IOChar.cursor_up + IOChar.clear_line ) * lines + IOChar.clear_line\n end",
"def clear_to_cursor; print \"\\e[1K\" end",
"def clear\n puts \"\\n\" # pour certaines méthodes\n puts \"\\033c\"\nend",
"def clear_to_beginning\n ConsoleGlitter.escape('1J')\n end",
"def clear_to_end\n ConsoleGlitter.escape('0J')\n end",
"def clear_screen\n \"\\e[2J\\e[H\"\nend",
"def clear_screen\n system \"clear\" or system \"cls\"\nend",
"def clear\n VIM::command(\"%d\")\n end",
"def clear\n puts \"\\e[2J\\e[f\"\nend",
"def clear\n WIN_OS ? system(\"cls\") : system(\"clear\")\n end",
"def clear_output\n clear_output = ''\n\n (by..byn).each do |row|\n clear_output << \"\\e[#{row};#{bx}H\" + (' ' * width)\n end\n\n # reset cursor to top left of document\n clear_output << \"\\e[#{by};#{bx}H\"\n end",
"def clear!\n @output = ''\n @verbose = false\n end",
"def clear_terminal\n Gem.win_platform? ? (system 'cls') : (system 'clear')\nend",
"def clearConsole()\n system \"clear\" or system \"cls\"\nend",
"def clearConsole()\n system \"clear\" or system \"cls\"\nend",
"def clear_stdout\n $stdout.string = '' if $stdout.is_a?(StringIO)\n end",
"def clear_line\n CLEAR_LINE\n end",
"def rl_clear_screen(count, key)\r\n if (@rl_explicit_arg)\r\n rl_refresh_line(count, key)\r\n return 0\r\n end\r\n\r\n _rl_clear_screen() # calls termcap function to clear screen\r\n rl_forced_update_display()\r\n @rl_display_fixed = true\r\n 0\r\n end",
"def clear_screen\n puts `clear`\nend",
"def clear\n Vedeu::Direct.write(value: clear_output, x: bx, y: by)\n end",
"def clear_screen\r\n RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/ ? system(\"cls\") : system(\"clear\")\r\n end",
"def clear_screen\n CLEAR_SCREEN\n end",
"def sleep_and_clear(seconds)\n sleep(seconds)\n system \"clear\" or system \"cls\"\nend",
"def clean_terminal\r\n Gem.win_platform? ? (system \"cls\") : (system \"clear\")\r\n end",
"def clear_up_to_cursor; puts \"\\e[1J\" end",
"def clear_cli\n system 'clear'\n end",
"def clear()\n \n if OS.linux? or OS.mac?\n\n system(\"clear\")\n\n elsif OS.windows?\n\n system(\"cls\")\n\n end\n\n end",
"def reset_screen_clearing\n @clear_screen = false\n @clear_screen_code = \"\\e[H\\e[2J\"\n end",
"def clear_stdout!\n @stdout_handler.clear!\n end",
"def puts_clear; puts \"\\e[0J\" end",
"def clear_line\n print \"\\r%s\\r\" % ' ' * columns\n end",
"def clear\n # Work in both unix and win32 shells\n system(\"cls\") || system(\"clear\")\nend",
"def reset\n update!({ status: :inactive, stdout: '', stderr: '', error: 0, point: 0, feedback: '' })\n end",
"def clear_screen\n\tGem.win_platform? ? (system \"cls\") : (system \"clear\")\nend",
"def clear_line\n CSI + '2K' + column(1)\n end",
"def clear\n \"\\e[2J\\e[H\"\nend",
"def _clear_line(lines = 1)\n raise ArgumentError, \"Number of lines to clear (#{lines}) must be > 0\" if lines < 1\n while lines > 0\n STDOUT.write \"\\r\\e[2K\"\n lines -= 1\n STDOUT.write \"\\e[A\" if lines > 0\n end\n end",
"def self_clear\n print \"\\e[2J\\e[f\"\nend",
"def clear\n closed!\n @leds.fill 0\n self\n end",
"def refresh(lines)\n @prompt.clear_lines(lines) +\n @prompt.cursor.clear_screen_down\n end",
"def reset_ui\n\t\tconsole.unset_log_source\n\t\tconsole.reset_ui\n\tend",
"def reset_ui\n\t\tconsole.unset_log_source\n\t\tconsole.reset_ui\n\tend",
"def reset_screen\n print \"\\e[2J\\e[H\"\nend",
"def clear\n @display.clear\n end",
"def clear\n io.truncate(0)\n io_index.clear\n self\n end",
"def flush_input\n Ncurses.flushinp\n end",
"def blank\n print \"\\r\"\n if @last_print_msg\n print ' ' * IO.console.winsize[1]\n end\n print \"\\r\"\n end",
"def clear_line_after\n CSI + '0K'\n end",
"def clear_screen\n Gem.win_platform? ? (system \"cls\") : (system \"clear\")\nend",
"def clear_screen\n Gem.win_platform? ? (system \"cls\") : (system \"clear\")\nend",
"def clear_screen\n Gem.win_platform? ? (system \"cls\") : (system \"clear\")\nend",
"def clear\n @pixels.fill WHITE\n end",
"def stop_spinner\n @spinner_running = false\n print \"\\b\"\n end",
"def clear_screen(str = \"\")\n \"\\x1b[H\\x1b[2J#{\n str\n }\"\n end"
] |
[
"0.76503116",
"0.7068279",
"0.70485336",
"0.69376385",
"0.6849531",
"0.6820603",
"0.68204975",
"0.6789234",
"0.6782584",
"0.67592484",
"0.67498493",
"0.6729563",
"0.6717679",
"0.6708802",
"0.6690987",
"0.6677897",
"0.6676975",
"0.66718906",
"0.667078",
"0.6648937",
"0.6631548",
"0.6628123",
"0.66205055",
"0.65924037",
"0.65915024",
"0.6585763",
"0.6585763",
"0.65693414",
"0.6568023",
"0.6568023",
"0.6565084",
"0.655899",
"0.654571",
"0.6543784",
"0.6541282",
"0.6534598",
"0.65337783",
"0.6532005",
"0.6503967",
"0.6475569",
"0.64479405",
"0.64479405",
"0.6439688",
"0.64272463",
"0.64191407",
"0.6417767",
"0.6410049",
"0.64081514",
"0.63686144",
"0.63652533",
"0.6325712",
"0.63106316",
"0.62907326",
"0.62715507",
"0.6264451",
"0.6264317",
"0.6247134",
"0.62073123",
"0.62048113",
"0.6195516",
"0.6195516",
"0.6178014",
"0.6174428",
"0.6172363",
"0.6169359",
"0.6168867",
"0.61660445",
"0.61599404",
"0.61481464",
"0.6142944",
"0.61427563",
"0.614108",
"0.61263645",
"0.61063385",
"0.61024046",
"0.60724324",
"0.6040339",
"0.6036867",
"0.60259944",
"0.5999491",
"0.59909433",
"0.59876215",
"0.59874195",
"0.59852976",
"0.59668875",
"0.5952276",
"0.5938575",
"0.5938575",
"0.5934981",
"0.5932569",
"0.59115314",
"0.5908991",
"0.59078777",
"0.5899117",
"0.589372",
"0.589372",
"0.589372",
"0.58929724",
"0.5889593",
"0.58677083"
] |
0.85260814
|
0
|
Displays an unformatted line to the logger output stream, adding a newline.
|
def puts(msg = '')
print("#{msg}\n")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def newline\n log\n end",
"def newline\n log('')\n end",
"def newline\n log('')\n end",
"def ReportLine(line)\n Builtins.y2milestone(\"%1\", line)\n UI.ChangeWidget(Id(:log_view), :LastLine, Ops.add(line, \"\\n\"))\n\n nil\n end",
"def log_line(line)\n if config.colorize_logging\n @@row_even, message_color = if @@row_even\n [false, '4;32;1']\n else\n [true, '4;33;1']\n end\n\n config.logger.info(\" [\\e[#{message_color}m%s\\e[0m] %s\" % [@name, line])\n else\n config.logger.info(\"[%s] %s\" % [@name, line])\n end\n end",
"def log(str, newline = true)\n @out.print(str)\n @out.print(\"\\n\") if newline\n end",
"def line_feed\n write_raw \"\\n\"\n end",
"def print_in_same_line(log_string)\n print log_string + \"\\r\"\n end",
"def send_raw_line(line)\n @logger.debug \"<< #{line}\" if @logger\n @socket.puts(line)\n end",
"def log(text=\"\", new_line=true)\n if current_server\n current_server.log(text, new_line)\n else\n text += \"\\n\" if new_line && text[-1] != ?\\n\n print(text)\n end\n end",
"def print_line(fields)\n output.puts(format_with_color(fields[:color], format_line(fields)))\n end",
"def output( line )\n puts( line ) \n end",
"def put_line(line = nil)\n commit_status()\n puts line\n STDOUT.flush\n end",
"def receive_line(line)\n Invoker::Logger.puts \"#{@command_label.color(color)} : #{line}\"\n end",
"def log(str, newline = true)\n return puts(str) if newline\n\n print str.ljust(60, ' ')\n STDOUT.flush\nend",
"def log_line(line)\n return if @appium_logger.nil?\n @appium_logger.info(\"Appium:#{@pid}\") { line }\n end",
"def print_line(msg='')\n end",
"def add_line(line)\n @tip.string_content += line.slice(@offset, line.length) + '\\n'\n end",
"def writeLine( length=75, char=\"-\" )\n\t\t\t$stderr.puts \"\\r\" + (char * length )\n\t\tend",
"def status_line(line)\n @status_line = line\n unless @ping_from\n # Display this status line.\n STDOUT.write \"\\r\" # Move to the start of this line.\n STDOUT.write line # Write over it.\n STDOUT.flush\n end\n end",
"def log(line)\n\t\tfile=File.open(@output_file,\"a+\")\n\t\tfile.puts(line)\n\t\tfile.close\n\tend",
"def newline\n @printer.nl\n end",
"def print_line(indent_level, string)\n $evm.log(\"info\", \"#{$method}:[#{indent_level.to_s}] #{string}\")\nend",
"def write(message)\n logger.info message unless message == \"\\n\"\n end",
"def log(output, newline = true)\n @out.print(output)\n @out.print(\"\\n\") if newline\n end",
"def log(output, newline = true)\n @out.print(output)\n @out.print(\"\\n\") if newline\n end",
"def print (client, line)\n if client != nil \n client.puts(line)\n end\n puts line\n end",
"def print_line(msg = '')\n # TODO: there are unhandled quirks in async output buffering that\n # we have not solved yet, for instance when loading meterpreter\n # extensions, supporting Windows, printing output from commands, etc.\n # Remove this guard when issues are resolved.\n=begin\n if (/mingw/ =~ RUBY_PLATFORM)\n print(msg + \"\\n\")\n return\n end\n print(\"\\033[s\") # Save cursor position\n print(\"\\r\\033[K\" + msg + \"\\n\")\n if input and input.prompt\n print(\"\\r\\033[K\")\n print(input.prompt.tr(\"\\001\\002\", ''))\n print(input.line_buffer.tr(\"\\001\\002\", ''))\n print(\"\\033[u\\033[B\") # Restore cursor, move down one line\n end\n=end\n\n print(msg + \"\\n\")\n end",
"def begin_of_line\n write_raw \"\\r\"\n end",
"def receive_line line\n super(line)\n write_output\n end",
"def output_line(line)\n output = line[:mode] + ' '\n output << line[:repl] + ' '\n output << line[:owner].ljust(@alignment[:owner]) + ' '\n output << line[:group].ljust(@alignment[:group]) + ' '\n output << line[:size].rjust(@alignment[:size]) + ' '\n output << line[:time] + ' '\n output << line[:name] + \"\\n\"\n puts output\n end",
"def displayln(out=$stdout)\n out.puts self\n end",
"def print_line(line)\n @maxlinelength = line.length if line.length > @maxlinelength\n print line.ljust(@maxlinelength) << \"\\r\"\n $stdout.flush\nend",
"def print!(type, line)\n remove_prefix! line\n line = CGI::escapeHTML(line)\n @packet.add_message(type, line)\nend",
"def line(length)\r\n puts '-'*length\r\n end",
"def log_lines\n\n self.each do |line|\n clean_line = line.to_s.chomp.gsub(\"\\\\n\",\"\")\n log.info(x) { line } if clean_line.length > 0\n end\n\n end",
"def write_line data\n _data[:out].puts data\n _data[:out].flush\n end",
"def write(line)\n begin\n @sock.puts line\n rescue\n end\n puts \">> #{line}\"\n end",
"def add_line(s=nil)\n @string << \"\\n#{@@indenation * @indentation_level}#{s}\"\n end",
"def render_line(line)\n raise NotImplementedError\n end",
"def send_line (line)\n send_data line.to_s\n end",
"def append_newline\n buffer << \"\\n\"\n @current_line_length = 0\n end",
"def log_line(line)\n puts \"cron_task:continuous:#{@process_name} : #{line}\"\n end",
"def print_new_line\n puts ''\nend",
"def append_new_line(new_line)\n # Append 'line' into position 'line_number'\n puts ' append_new_line ...' if $verbose > 1\n @lines << new_line\n @line_count += 1\n end",
"def send_line(line = '')\n reset_timeout!\n\n send_data(line + CRLF)\n\n debug_notification(:send, line.inspect)\n end",
"def print_line(nlen, n, clen, c)\n puts \"%-#{nlen}s | %-#{clen}s \" % [n, c]\n end",
"def append_line(line)\n @entries.last.line << line\n end",
"def empty_line\r\n puts \"\\n\"\r\n end",
"def line\n puts \"########################################################\"\nend",
"def putline(line)\n @socket.puts(line.chomp)\n end",
"def puts(line)\n events.stream_output(:profiler, line+\"\\n\")\n end",
"def show\n \"\\t#{@line}: #{first_line}\"\n end",
"def line(opts = { print: true })\n if color?\n result = ANSI_CODES[:bold] + GLYPHS[:heavy_dash] * 80 + ANSI_CODES[:reset] + \"\\n\"\n else\n result = \"-\" * 80 + \"\\n\"\n end\n print_or_return(result, opts[:print])\n end",
"def log(text=\"\", new_line=true)\n current_server ? current_server.log(text, new_line) : super(text, new_line)\n end",
"def newline; end",
"def writeline(str)\n writing { write0 str + \"\\r\\n\" }\n end",
"def log(text=\"\", new_line=true)\n super(DO_LOGGER_FORMAT % [user, name, text], new_line)\n end",
"def line\n\tputs \"-\" * 100\nend",
"def write_line(data); end",
"def output(str, newline=true)\n str = str.to_s\n if newline\n str += \"\\n\"\n end\n\n # add timestamp info only to lines containing newlines\n if str =~ /\\n/\n str_with_timestamps = \"\"\n str.split(\"\\n\").each do |line|\n timeformat = \"%H:%M:%S\"\n now = Time.now\n timestring = now.strftime(timeformat) + \".\" + (\"%06d\" % now.usec)[0..2]\n str_with_timestamps += \"[#{timestring}] \" + line + \"\\n\"\n end\n str = str_with_timestamps\n end\n output_log(str)\n if @command_line_output\n output_stdout(str)\n end\n end",
"def << message\n message.each_line do |line|\n @ui.info(line, :new_line => false)\n end\n end",
"def send_response(line)\n @logger.info(self.class) { line }\n @socket.puts(line)\n end",
"def put_a_line\n puts \"\\n\"\n puts \"/\\\\\" * 40\n puts \"\\n\"\n end",
"def nl\n @linebreak = true\n end",
"def new_line\n puts \"\\n\"\nend",
"def new_line\n puts \"\\n\"\nend",
"def log(line)\n Log.info(\"#{@indexer_name} [#{Time.now}] #{line}\")\n end",
"def line(*font)\n @io.puts(tag(:hr))\n end",
"def output_log(log)\n puts \"\\e[32m#{log}\\e[m\\s\"\nend",
"def writeln(string)\n write string.end_with?(\"\\n\") ? string : \"#{string}\\n\"\n end",
"def newline\n puts\n end",
"def show_line\n say \"=\" * 25\nend",
"def newline\n print \"\\n\"\n end",
"def line_break\n append '(?:\\n|(?:\\r\\n))'\n end",
"def write(string)\n sanitized_string = string.to_s.chomp(\"\\n\")\n @logger.send(@method, sanitized_string) if sanitized_string.size > 0\n end",
"def newline\n @results += nl\n end",
"def output()\n add_newline if @linebreak\n @text\n end",
"def draw_line\n print H_SEP * columns\n end",
"def fancy_newline\n @results += '|'\n newline\n end",
"def linebreak(amount=1)\n $stdout.print \"\\n\" * amount\n end",
"def puts(msg)\n # print msg\n # print \"\\n\"\n @lines << \"#{msg}\\n\"\nend",
"def append_line\n File.open(path, 'w') do |fh|\n lines.each do |l|\n fh.puts(l)\n end\n fh.puts line\n end\n end",
"def add_line_breaks(str)\n simple_format(str, {}, sanitize: false)\n end",
"def log(msg)\n lines = msg.split(/\\n/)\n\n STDERR.puts \"** #{lines.first}\"\n lines[1..-1].each do |line|\n STDERR.puts\" #{line}\"\n end\n end",
"def response_line\n \"#{Protocol::NAME}/#{@version} #{@code} #{@message}#{Protocol::CRLF}\"\n end",
"def line\n\t\t\t@line.set(buffer.line.start, buffer.line.end)\n\t\tend",
"def detail\n \"#{line}\\n#{' ' * line_offset}^\"\n end",
"def write_basic_line(io, line_key, line_value, validators)\n return if !line_value || line_value.empty?\n line_value.strip!\n valid = validate_line_value(line_value, validators)\n if valid || !@raise_on_invalid_data\n io.puts \"#{line_key}: #{line_value}\"\n elsif validators && !validators.empty? && @raise_on_invalid_data\n raise InvalidDataError, \"Invalid value: `#{line_value}` given for key `#{line_key}`\"\n end\n end",
"def writeln(input)\r\n target.puts input\r\n self\r\n end",
"def erase_line\n # highline does not expose the output stream\n HighLine.default_instance.instance_variable_get('@output').print \"\\r\\e[K\"\n end",
"def log(text)\n puts text\n end",
"def print_out_line\n name = @run_name\n name += \" (res: #@restart_id)\" if @restart_id\n name += \" real_id: #@real_id\" if @real_id\n beginning = sprintf(\"%2d:%d %-60s %1s:%2.1f(%s) %3s%1s\", @id, @job_no, name, @status.to_s[0,1], @run_time.to_f / 60.0, @nprocs.to_s, percent_complete, \"%\")\n if ctd\n #beginning += sprintf(\"Q:%f, Pfusion:%f MW, Ti0:%f keV, Te0:%f keV, n0:%f x10^20\", fusionQ, pfus, ti0, te0, ne0)\n end\n beginning += \" ---#{@comment}\" if @comment\n beginning\n end",
"def log(message)\n puts \">> #{message}\"\n end",
"def call(severity, timestamp, progname, msg)\n \"#{format(msg)}#{Lumberjack::LINE_SEPARATOR}\"\n end",
"def newline\n io << \"\\n\"\n io << (\" \" * @__indent__.to_i)\n end",
"def send_line(line)\n connect unless connected?\n warn \"-> #{line}\" if @options[:debug]\n @socket.write(line.to_s + \"\\n\")\n @socket.flush\n self\n end",
"def render_spacer\n puts \"\\n\"\n end",
"def render\n if @location.line == @location.last_line || @location.is?(\"\\n\")\n [\"#{@location}: #{@level}: #{message}\"] + render_line(@location)\n else\n # multi-line diagnostic\n first_line = first_line_only(@location)\n last_line = last_line_only(@location)\n num_lines = (@location.last_line - @location.line) + 1\n buffer = @location.source_buffer\n\n last_lineno, last_column = buffer.decompose_position(@location.end_pos)\n [\"#{@location}-#{last_lineno}:#{last_column}: #{@level}: #{message}\"] +\n render_line(first_line, num_lines > 2, false) +\n render_line(last_line, false, true)\n end\n end",
"def log(s)\n log_stream.puts(s)\n end",
"def enter(line)\n @standard_output.advance\n @standard_error.advance\n @stdin.puts line\n end"
] |
[
"0.7241168",
"0.7230651",
"0.7230651",
"0.7191988",
"0.7018187",
"0.68045485",
"0.67703605",
"0.6522741",
"0.6515393",
"0.64406544",
"0.6417612",
"0.638652",
"0.63512725",
"0.6301302",
"0.6262147",
"0.62473214",
"0.62353235",
"0.6183429",
"0.61749005",
"0.6151485",
"0.6148638",
"0.6106603",
"0.6093984",
"0.6040231",
"0.6020908",
"0.6020908",
"0.5986548",
"0.59590024",
"0.59386754",
"0.5908679",
"0.590861",
"0.59004277",
"0.5893213",
"0.5892026",
"0.5887795",
"0.5886021",
"0.58746195",
"0.58698994",
"0.5868954",
"0.585172",
"0.5840342",
"0.5828161",
"0.58278483",
"0.5826102",
"0.5791913",
"0.57815546",
"0.5778966",
"0.57652754",
"0.5758707",
"0.57549506",
"0.57542074",
"0.57527834",
"0.57380235",
"0.5731754",
"0.5729098",
"0.5726951",
"0.5725364",
"0.57202536",
"0.5714617",
"0.5709461",
"0.5694235",
"0.56773716",
"0.5673979",
"0.5672541",
"0.5651801",
"0.5649967",
"0.5649967",
"0.56433094",
"0.5638232",
"0.5608449",
"0.56030625",
"0.56019044",
"0.5594649",
"0.55879295",
"0.5584931",
"0.55845267",
"0.5576018",
"0.55737334",
"0.5564638",
"0.5561205",
"0.55596447",
"0.5554735",
"0.5554591",
"0.5540377",
"0.5533291",
"0.5511844",
"0.5496259",
"0.5486885",
"0.5480353",
"0.54774183",
"0.54581004",
"0.5457408",
"0.5451613",
"0.54512405",
"0.5436611",
"0.54358995",
"0.5426868",
"0.5422509",
"0.54224646",
"0.5420598",
"0.5401339"
] |
0.0
|
-1
|
Displays an unformatted line to the logger output stream.
|
def print(msg = '')
clear_line
print_no_newline(msg)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def log_line(line)\n if config.colorize_logging\n @@row_even, message_color = if @@row_even\n [false, '4;32;1']\n else\n [true, '4;33;1']\n end\n\n config.logger.info(\" [\\e[#{message_color}m%s\\e[0m] %s\" % [@name, line])\n else\n config.logger.info(\"[%s] %s\" % [@name, line])\n end\n end",
"def ReportLine(line)\n Builtins.y2milestone(\"%1\", line)\n UI.ChangeWidget(Id(:log_view), :LastLine, Ops.add(line, \"\\n\"))\n\n nil\n end",
"def send_raw_line(line)\n @logger.debug \"<< #{line}\" if @logger\n @socket.puts(line)\n end",
"def render_line(line)\n raise NotImplementedError\n end",
"def output( line )\n puts( line ) \n end",
"def receive_line(line)\n Invoker::Logger.puts \"#{@command_label.color(color)} : #{line}\"\n end",
"def print_line(fields)\n output.puts(format_with_color(fields[:color], format_line(fields)))\n end",
"def print_line(msg='')\n end",
"def status_line(line)\n @status_line = line\n unless @ping_from\n # Display this status line.\n STDOUT.write \"\\r\" # Move to the start of this line.\n STDOUT.write line # Write over it.\n STDOUT.flush\n end\n end",
"def newline\n log('')\n end",
"def newline\n log('')\n end",
"def newline\n log\n end",
"def put_line(line = nil)\n commit_status()\n puts line\n STDOUT.flush\n end",
"def log_line(line)\n return if @appium_logger.nil?\n @appium_logger.info(\"Appium:#{@pid}\") { line }\n end",
"def show\n \"\\t#{@line}: #{first_line}\"\n end",
"def print!(type, line)\n remove_prefix! line\n line = CGI::escapeHTML(line)\n @packet.add_message(type, line)\nend",
"def print_in_same_line(log_string)\n print log_string + \"\\r\"\n end",
"def puts(line)\n events.stream_output(:profiler, line+\"\\n\")\n end",
"def display(line, column=0)\n result = \"\\e[s\"\n result << \"\\e[#{line.to_i};#{column.to_i}H\"\n result << to_s\n result << \"\\e[u\"\n result\n end",
"def line(length)\r\n puts '-'*length\r\n end",
"def display(src, line)\n if src.respond_to? :prefix\n @io.print \"#{reset('')}#{src.prefix}#{reset(bg(fg(line)))}\\n\"\n else\n @io.print \"#{reset(bg(fg(line)))}\\n\"\n end\n end",
"def writeLine( length=75, char=\"-\" )\n\t\t\t$stderr.puts \"\\r\" + (char * length )\n\t\tend",
"def log(str, newline = true)\n @out.print(str)\n @out.print(\"\\n\") if newline\n end",
"def line\n\tputs \"-\" * 100\nend",
"def receive_line line\n super(line)\n write_output\n end",
"def print_line(indent_level, string)\n $evm.log(\"info\", \"#{$method}:[#{indent_level.to_s}] #{string}\")\nend",
"def send_line (line)\n send_data line.to_s\n end",
"def log_lines\n\n self.each do |line|\n clean_line = line.to_s.chomp.gsub(\"\\\\n\",\"\")\n log.info(x) { line } if clean_line.length > 0\n end\n\n end",
"def log_line(line)\n puts \"cron_task:continuous:#{@process_name} : #{line}\"\n end",
"def print (client, line)\n if client != nil \n client.puts(line)\n end\n puts line\n end",
"def log(line)\n\t\tfile=File.open(@output_file,\"a+\")\n\t\tfile.puts(line)\n\t\tfile.close\n\tend",
"def add_line(line)\n @tip.string_content += line.slice(@offset, line.length) + '\\n'\n end",
"def detail\n \"#{line}\\n#{' ' * line_offset}^\"\n end",
"def log(line)\n Log.info(\"#{@indexer_name} [#{Time.now}] #{line}\")\n end",
"def line(opts = { print: true })\n if color?\n result = ANSI_CODES[:bold] + GLYPHS[:heavy_dash] * 80 + ANSI_CODES[:reset] + \"\\n\"\n else\n result = \"-\" * 80 + \"\\n\"\n end\n print_or_return(result, opts[:print])\n end",
"def output_line(line)\n output = line[:mode] + ' '\n output << line[:repl] + ' '\n output << line[:owner].ljust(@alignment[:owner]) + ' '\n output << line[:group].ljust(@alignment[:group]) + ' '\n output << line[:size].rjust(@alignment[:size]) + ' '\n output << line[:time] + ' '\n output << line[:name] + \"\\n\"\n puts output\n end",
"def render\n if @location.line == @location.last_line || @location.is?(\"\\n\")\n [\"#{@location}: #{@level}: #{message}\"] + render_line(@location)\n else\n # multi-line diagnostic\n first_line = first_line_only(@location)\n last_line = last_line_only(@location)\n num_lines = (@location.last_line - @location.line) + 1\n buffer = @location.source_buffer\n\n last_lineno, last_column = buffer.decompose_position(@location.end_pos)\n [\"#{@location}-#{last_lineno}:#{last_column}: #{@level}: #{message}\"] +\n render_line(first_line, num_lines > 2, false) +\n render_line(last_line, false, true)\n end\n end",
"def print_line(line)\n @maxlinelength = line.length if line.length > @maxlinelength\n print line.ljust(@maxlinelength) << \"\\r\"\n $stdout.flush\nend",
"def output_log(log)\n puts \"\\e[32m#{log}\\e[m\\s\"\nend",
"def line\n puts \"########################################################\"\nend",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def print_line(msg = '')\n # TODO: there are unhandled quirks in async output buffering that\n # we have not solved yet, for instance when loading meterpreter\n # extensions, supporting Windows, printing output from commands, etc.\n # Remove this guard when issues are resolved.\n=begin\n if (/mingw/ =~ RUBY_PLATFORM)\n print(msg + \"\\n\")\n return\n end\n print(\"\\033[s\") # Save cursor position\n print(\"\\r\\033[K\" + msg + \"\\n\")\n if input and input.prompt\n print(\"\\r\\033[K\")\n print(input.prompt.tr(\"\\001\\002\", ''))\n print(input.line_buffer.tr(\"\\001\\002\", ''))\n print(\"\\033[u\\033[B\") # Restore cursor, move down one line\n end\n=end\n\n print(msg + \"\\n\")\n end",
"def line_feed\n write_raw \"\\n\"\n end",
"def throw_away_meaningless_line\n\t\tputs \"I have no idea what you are talking about\"\n\tend",
"def show_line\n say \"=\" * 25\nend",
"def display(text)\n @log ||= Logger.new(STDERR)\n @log.info text\n end",
"def display(text)\n @log ||= Logger.new(STDERR)\n @log.info text\n end",
"def display(line, column=0) #:yield:\n result = \"\\e[s\"\n result << \"\\e[#{line.to_i};#{column.to_i}H\"\n if block_given?\n result << yield\n result << \"\\e[u\"\n #elsif string\n # result << string\n # result << \"\\e[u\"\n end\n result\n end",
"def displayln(out=$stdout)\n out.puts self\n end",
"def h_line\n puts \"-\" * 80\n nil\nend",
"def log(text=\"\", new_line=true)\n if current_server\n current_server.log(text, new_line)\n else\n text += \"\\n\" if new_line && text[-1] != ?\\n\n print(text)\n end\n end",
"def log(str, newline = true)\n return puts(str) if newline\n\n print str.ljust(60, ' ')\n STDOUT.flush\nend",
"def h_line\n puts \"-\" * 50\n nil\nend",
"def display(line, column = T.unsafe(nil)); end",
"def display(line, column = T.unsafe(nil)); end",
"def display(line, column = T.unsafe(nil)); end",
"def print_out_line\n name = @run_name\n name += \" (res: #@restart_id)\" if @restart_id\n name += \" real_id: #@real_id\" if @real_id\n beginning = sprintf(\"%2d:%d %-60s %1s:%2.1f(%s) %3s%1s\", @id, @job_no, name, @status.to_s[0,1], @run_time.to_f / 60.0, @nprocs.to_s, percent_complete, \"%\")\n if ctd\n #beginning += sprintf(\"Q:%f, Pfusion:%f MW, Ti0:%f keV, Te0:%f keV, n0:%f x10^20\", fusionQ, pfus, ti0, te0, ne0)\n end\n beginning += \" ---#{@comment}\" if @comment\n beginning\n end",
"def erase_line\n # highline does not expose the output stream\n HighLine.default_instance.instance_variable_get('@output').print \"\\r\\e[K\"\n end",
"def write(line)\n begin\n @sock.puts line\n rescue\n end\n puts \">> #{line}\"\n end",
"def send_line(line = '')\n reset_timeout!\n\n send_data(line + CRLF)\n\n debug_notification(:send, line.inspect)\n end",
"def line(*font)\n @io.puts(tag(:hr))\n end",
"def log(msg)\n lines = msg.split(/\\n/)\n\n STDERR.puts \"** #{lines.first}\"\n lines[1..-1].each do |line|\n STDERR.puts\" #{line}\"\n end\n end",
"def print_line(nlen, n, clen, c)\n puts \"%-#{nlen}s | %-#{clen}s \" % [n, c]\n end",
"def write_line data\n _data[:out].puts data\n _data[:out].flush\n end",
"def draw_line\n print H_SEP * columns\n end",
"def line\n\t\t\t@line.set(buffer.line.start, buffer.line.end)\n\t\tend",
"def log(text)\n puts text\n end",
"def log_to_console\n location = @location[1..-1] # remove file_descriptor\n details = @details.first(2) # remove additional details\n [\n ' ',\n location.join(', ').ljust(33),\n details.join(': ')\n ].join\n end",
"def throw_away_meaningless_line\n puts \"I have no idea what you are talking about\"\n end",
"def event_display_line(msg, room)\n msg.replace(\"#{Time.now.strftime(@var[:timestamp])}#{msg}\") if msg\nend",
"def line\n end",
"def line\n end",
"def send_response(line)\n @logger.info(self.class) { line }\n @socket.puts(line)\n end",
"def dp_line(line, options = { filename: '', char: '-' })\n filename = options[:filename].nil? ? '' : options[:filename]\n char = options[:char].nil? ? '-' : options[:char]\n puts \"#{char * 20}|filename=#{filename}|line=#{line}|#{char * 20}\"\n end",
"def write_basic_line(io, line_key, line_value, validators)\n return if !line_value || line_value.empty?\n line_value.strip!\n valid = validate_line_value(line_value, validators)\n if valid || !@raise_on_invalid_data\n io.puts \"#{line_key}: #{line_value}\"\n elsif validators && !validators.empty? && @raise_on_invalid_data\n raise InvalidDataError, \"Invalid value: `#{line_value}` given for key `#{line_key}`\"\n end\n end",
"def log(text=\"\", new_line=true)\n super(DO_LOGGER_FORMAT % [user, name, text], new_line)\n end",
"def write_line(data); end",
"def print(line)\n if $output_filename == '__to_stdout'\n printf(\"%s\",line)\n else\n f = File.open($output_filename,'a')\n f.write(line)\n f.close()\n end\nend",
"def begin_of_line\n write_raw \"\\r\"\n end",
"def render_output(should_flood, start_line, text, color=:blue)\n if start_line\n text = Pry::Helpers::Text.with_line_numbers text, start_line, color\n end\n\n if should_flood\n output.puts text\n else\n stagger_output(text)\n end\n end",
"def print_a_line(printer, string)\n printer.print_line string\nend",
"def log(s)\n log_stream.puts(s)\n end",
"def string\n @line\n end",
"def call(severity, timestamp, progname, msg)\n \"#{format(msg)}#{Lumberjack::LINE_SEPARATOR}\"\n end",
"def log(line)\n puts line unless RUBYMOTION_ENV == \"test\"\n end",
"def format_log(msg)\n msg = colorize_log(msg)\n msg = remove_prefix(msg)\n \"#{msg}\\n\"\n end",
"def gamelog(line)\r\nend"
] |
[
"0.7140746",
"0.6922101",
"0.6441453",
"0.6429609",
"0.64163303",
"0.6390289",
"0.6370111",
"0.6343696",
"0.62569064",
"0.6244328",
"0.6244328",
"0.6238196",
"0.6227454",
"0.61564016",
"0.6131584",
"0.61305743",
"0.60429645",
"0.6029203",
"0.60040027",
"0.59866387",
"0.59810185",
"0.596481",
"0.5952005",
"0.5901142",
"0.5898913",
"0.5897534",
"0.58890194",
"0.5886706",
"0.5884958",
"0.5876157",
"0.58733755",
"0.5848734",
"0.58473444",
"0.58469003",
"0.5830297",
"0.5829189",
"0.5807489",
"0.5767395",
"0.576572",
"0.57519954",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5724531",
"0.5707021",
"0.5702538",
"0.5686",
"0.56838703",
"0.5673845",
"0.5673845",
"0.56607515",
"0.5660523",
"0.56580037",
"0.56533504",
"0.5643041",
"0.5633191",
"0.56089175",
"0.56089175",
"0.56089175",
"0.5605454",
"0.5595898",
"0.5579541",
"0.5564243",
"0.5562312",
"0.55541974",
"0.5550683",
"0.55347115",
"0.5529253",
"0.55215806",
"0.5517662",
"0.54780644",
"0.5462395",
"0.5459036",
"0.5454588",
"0.5454588",
"0.5441601",
"0.5431503",
"0.5419612",
"0.5411149",
"0.5406795",
"0.54058",
"0.5404435",
"0.53976506",
"0.53894454",
"0.535453",
"0.5344382",
"0.5331048",
"0.5320197",
"0.5316388",
"0.5312494"
] |
0.0
|
-1
|
Prints the backtrace +exc+ to the logger as error data.
|
def backtrace(exc, level_meth = :error)
return unless show_backtraces
send(level_meth, "#{exc.class.class_name}: #{exc.message}")
send(level_meth, "Stack trace:" +
exc.backtrace[0..5].map {|x| "\n\t#{x}" }.join + "\n")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def error(msg, exc=nil)\n return synchronize{@out.print(\"#{@error}#{msg}\\n\")} unless exc\n synchronize{@out.print(\"#{@error}#{msg}: #{exc}\\n#{exc.backtrace.join(\"\\n\")}\\n\")}\n end",
"def exception(ex, msg='')\n line = ''\n ex.backtrace.each do |l|\n line += \"\\n #{l}\"\n end\n @logger.error \"#{msg}: ** Exception thrown: #{ex.class}, backtrace follows:#{line}\"\n end",
"def _log_exception(icon, note, excpt)\n warn \"#{icon} #{note}:\\n#{EXPT} \\xE2\\x94\\x8C#{excpt} \\xE2\\x94\\x90\"\n warn excpt.backtrace[0..7].reduce(\"\") { |s,x|\n s += \"#{EXPT} \\xE2\\x94\\x9C#{x}\\n\" } +\n \"#{EXPT} \\xE2\\x94\\x94#{BAR*25}\\xE2\\x94\\x98\"\n end",
"def log_backtrace(e)\n Qwirk.logger.error \"\\t#{e.backtrace.join(\"\\n\\t\")}\"\n end",
"def visit_exception\n exception = object.value\n\n puts(\n EXCEPTION_ERROR_MESSAGE % [\n exception.inspect,\n exception.backtrace.join(\"\\n\")\n ]\n )\n end",
"def log_exception(ex)\n log_error { ex.message }\n log_error { ex.backtrace[0..5].join(\"\\n\") }\n log_debug { ex.backtrace.join(\"\\n\") }\n end",
"def error(exception)\n log \"#{exception.message}\\n#{exception.backtrace.join(\"\\n\")}\", :error\n end",
"def backtrace(exception)\n return unless Gem.configuration.backtrace\n\n @errs.puts \"\\t#{exception.backtrace.join \"\\n\\t\"}\"\n end",
"def error(ex)\n if ex.respond_to?(:exception)\n message = ex.backtrace\n message.map!{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }\n message.unshift(ex.inspect)\n else\n message = ex.to_s\n end\n tag_log(:error, :to_s, *message)\n end",
"def log_backtrace(exception, context_msg: '', re_raise: true, send_return: nil)\n context_msg = 'printing raised exception' if context_msg.length.zero?\n\n $ibm_cloud_log.error(format_message(context_msg))\n $ibm_cloud_log.log_backtrace(exception)\n raise if re_raise\n\n send_return\n end",
"def log_error(ex)\n if @config.logger.respond_to?(:error)\n @config.logger.error(\"CrashHook Error: #{ex.inspect}\")\n elsif @config.logger.kind_of?(IO)\n @config.logger.puts(\"CrashHook Error: #{ex.inspect}\")\n end\n end",
"def error exception, backtrace = nil\n backtrace ||= exception.backtrace\n unless backtrace.is_a? Array\n backtrace = [ backtrace ]\n end\n\n @errors << { :error => exception.to_s.gsub(\"\\n\", \" \"), :backtrace => backtrace }\n end",
"def log_exception ex\n logger.error ex\n logger.error ex.class\n logger.error ex.backtrace.join(\"\\n\")\n end",
"def log_error(exception); end",
"def log_error(title, exception)\n RAILS_DEFAULT_LOGGER.error \"#{title}: #{exception}\\n#{exception.backtrace.join(\"\\n\")}\"\n end",
"def try_with_pretty_error_log\n yield\n rescue RuntimeError => e\n begin\n openerp_error_hash = eval(\"#{ e }\".gsub(\"wrong fault-structure: \", \"\"))\n if openerp_error_hash.is_a? Hash\n logger.error \"*********** OpenERP Server ERROR:\n #{openerp_error_hash[\"faultString\"]}\n ***********\"\n end\n rescue\n end\n raise\n end",
"def exception(e)\n self.error \"#{e.class}: #{e.message}\" << (\"\\n#{e.backtrace.join(\"\\n\")}\" unless e.backtrace.nil?)\n end",
"def log_error(exception)\n logger.fatal do\n message = +\"#{exception.class} (#{exception.message}):\\n\\n\"\n message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_source_code)\n message << \" \" << exception.backtrace.join(\"\\n \")\n \"#{message}\\n\\n\"\n end\n end",
"def exc_msg_and_response(exc, response = nil)\n return [exc, exc.message, response] if exc.respond_to?(:backtrace)\n\n return [nil, \"the server responded with status #{exc[:status]}\", exc] \\\n if exc.respond_to?(:each_key)\n\n [nil, exc.to_s, response]\n end",
"def log_error(exception)\n logger.error(\n \"\\n#{exception.class} (#{exception.message}):\\n \" +\n Rails.backtrace_cleaner.clean(exception.backtrace).join(\"\\n \") + \"\\n\\n\"\n )\n end",
"def puts_ex(e)\n\tputs \"\\nException: #{e}\"\n\tputs e.backtrace\t\n end",
"def log_exception(e)\n error(e.inspect)\n e.backtrace.each { |line| error(line) }\n end",
"def backtrace(exc, level_meth = T.unsafe(nil)); end",
"def log_exception(e)\n log_err(e.message)\n log_err(e.backtrace.join(\"\\n\"))\n end",
"def error_for_exception(exception)\n\t\t\t\t[\"error\", exception.class.to_s, exception.message, exception.backtrace]\n\t\t\tend",
"def error_handler(exception)\n puts exception\n end",
"def error(exception)\n logger.error(exception)\n end",
"def write_exception_to_log(ex, exception_context, timestamp, log_context = {})\n ActiveSupport::Deprecation.silence do\n log_message = \"#{exception_context}\\n#{ex.class}: (#{encode_utf8(ex.message.to_s)}):\\n \" + clean_backtrace(ex).join(\"\\n \") + \"\\n\\n\"\n\n if ex.is_a?(Warning)\n ExceptionHandling.logger.warn(\"\\nExceptionHandlingWarning (Warning:#{timestamp}) #{log_message}\", **log_context)\n else\n ExceptionHandling.logger.fatal(\"\\nExceptionHandlingError (Error:#{timestamp}) #{log_message}\", **log_context)\n end\n end\n end",
"def print_error(e)\n puts e.message\n puts e.backtrace if(trace)\n end",
"def puts_stacktrace(exception)\n logger.debug \"\\033[1m\\033[32m#{exception.message}\\033[0m\\033[22m\"\n filtered_trace = exception.backtrace.grep(/#{Regexp.escape(\"nilavu\")}/)\n unless filtered_trace.empty?\n full_stacktrace = (filtered_trace.map { |ft| ft.split('/').last }).join(\"\\n\")\n logger.debug \"\\033[1m\\033[36m#{full_stacktrace}\\033[0m\\033[22m\"\n end\n logger.debug \"\\033[1m\\033[32m..(*_*)...\\033[0m\"\n end",
"def log_error(msg)\n\t\tprint_error(msg)\n\n\t\telog(msg, 'meterpreter')\n\n\t\tdlog(\"Call stack:\\n#{$@.join(\"\\n\")}\", 'meterpreter')\n\tend",
"def log_error(request, exception = $!)\n msg = StringIO.new\n msg.puts(\"Error handling request %p %p: %s (%p):\\n\\t%s\" %\n [ request.request_method, request.path_info,\n exception.message, exception.class,\n exception.backtrace.join(\"\\n\\t\") ])\n\n if exception.respond_to?(:cause)\n c = exception_cause(exception)\n while c\n msg.puts(\"Caused by: %s (%p):\\n\\t%s\" %\n [ c.message, c.class, c.backtrace.join(\"\\n\\t\") ])\n c = c.cause\n end\n end\n\n logger.error(msg.string)\n log_error_to_remote(request, exception)\n log_error_to_statsd(request, exception)\n end",
"def log_error(msg, res, ex)\n Puppet.err(\"%s for %s: Error %s:%s \" % [msg, res, ex.class, ex.message] )\n Puppet.err(\"Fault error message: %s\" % ex.fault.errMsg.to_s) if ex.is_a?(RbVmomi::Fault)\n end",
"def trace_errors\n getErrors.each { |e|\n puts \"(#{e.object || ''}): #{e.error}\"\n }\n end",
"def error(msg, exc: nil)\n must \"message\", msg, be: String\n\n tell(colorize(\"☠ \", :magenta) + colorize(msg, :red))\n\n if exc\n raise exc.new(msg)\n else\n exit(-1)\n end\n end",
"def print_exception(e)\n\tputs \"error: #{e.message}\"\nend",
"def log_exception(excp, meth = nil)\n error = warning = nil\n case excp\n when Shrine::FileNotFound then warning = 'FILE_NOT_FOUND'\n when Shrine::InvalidFile then warning = 'INVALID_FILE'\n when Shrine::AttachmentChanged then warning = 'ATTACHMENT_CHANGED'\n when Shrine::Error then error = 'unexpected Shrine error'\n else error = \"#{excp.class} unexpected\"\n end\n Log.add(error ? Log::ERROR : Log::WARN) do\n \"#{meth || __method__}: #{excp.message} [#{error || warning}]\"\n end\n end",
"def cmd_debug_error(ex)\n if $verbose\n $stderr.puts \"error: #{$!.class}: #{$!.to_s}\"\n $!.backtrace.each {|b|\n $stderr.puts \" #{b}\"\n }\n $stderr.puts \"\"\n end\n end",
"def cmd_debug_error(ex)\n if $verbose\n $stderr.puts \"error: #{$!.class}: #{$!.to_s}\"\n $!.backtrace.each {|b|\n $stderr.puts \" #{b}\"\n }\n $stderr.puts \"\"\n end\n end",
"def backtrace(exception)\n message = \"<br/>\" + sanitize(exception.message) + \"<br/>\"\n message += exception.backtrace.collect { |line|\n sanitize(line)\n }.join(\"<br/>\")\n return message\n end",
"def display_error_message(ex)\n $stderr.puts \"#{@name} aborted!\"\n $stderr.puts ex.message\n $stderr.puts ex.backtrace.join(\"\\n\")\n end",
"def log_exception(e)\n unless e.blank?\n log_error_with_timestamp e.inspect unless e.inspect.blank?\n log_error_with_timestamp e.backtrace.join(\"\\n \") unless e.backtrace.blank?\n end\nend",
"def service_backtrace exception\n service_logger.error exception.backtrace.first(20).map { |row| row.prepend(\"\\t\") }.join(\"\\n\")\n end",
"def format_error(exception)\n message = \"#{exception.class} (#{exception.respond_to?(:message) ? exception.message : exception.inspect}):\\n\"\n message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)\n message << ' ' << exception.backtrace.join(\"\\n \") if exception.respond_to?(:backtrace)\n message\n end",
"def log_error_rack(exception, env, _rack_filter)\n timestamp = set_log_error_timestamp\n exception_info = ExceptionInfo.new(exception, env, timestamp)\n\n if stub_handler\n stub_handler.handle_stub_log_error(exception_info.data)\n else\n # TODO: add a more interesting custom description, like:\n # custom_description = \": caught and processed by Rack middleware filter #{rack_filter}\"\n # which would be nice, but would also require changing quite a few tests\n custom_description = \"\"\n write_exception_to_log(exception, custom_description, timestamp)\n\n send_external_notifications(exception_info)\n\n nil\n end\n end",
"def handle_exception(e)\n puts \"\"\n puts \"An exception has occurred:\\n #{e.message} (#{e.class})\"\n puts \"Backtrace:\"\n output = Output.new\n output.set_columns(['%s', '%-s'], ' at ')\n bt = e.awesome_backtrace\n first = true\n bt.frames.each do |fr|\n recv = fr[0]\n loc = fr[1]\n break if recv =~ /Debugger#process_command/\n output.set_color(bt.color_from_loc(loc, first))\n first = false # special handling for first line\n output << [recv, loc]\n end\n puts output\n end",
"def display_abort(exception)\r\n puts;\r\n puts exception\r\n\r\n if debug\r\n puts\r\n puts \"Data Stack Contents:\"\r\n pp data_stack\r\n puts\r\n puts \"Control Stack Contents:\"\r\n pp ctrl_stack\r\n puts\r\n puts \"Mode = #{mode.inspect}, Level = #{level}\"\r\n end\r\n\r\n interpreter_reset\r\n compiler_reset\r\n end",
"def log_error(exception) #:doc:\n if ActionView::TemplateError === exception\n logger.fatal(exception.to_s)\n else\n logger.fatal(\n \"\\n\\n#{exception.class} (#{exception.message}):\\n \" + \n clean_backtrace(exception).join(\"\\n \") + \n \"\\n\\n\"\n )\n end\n end",
"def log_error(exception) #:doc:\n if ActionView::TemplateError === exception\n logger.fatal(exception.to_s)\n else\n logger.fatal(\n \"\\n\\n#{exception.class} (#{exception.message}):\\n \" + \n clean_backtrace(exception).join(\"\\n \") + \n \"\\n\\n\"\n )\n end\n end",
"def log_exception(e, sym=:error)\n ar = [e.message] \n ar = ar + e.backtrace\n ar.each do |element|\n puts \"#{sym} #{element}\"\n end\n if sym == :info && $dplayer_list\n $dplayer_list.each do |ch|\n if ch.level >= LEVEL_IMM\n ar.each do |element|\n ch.text_to_player element + ENDL\n end\n end\n end\n end\nend",
"def log_data_invalid_error(data, exception)\n open(OPERATION_IMPORT_LOG, 'a') do |file|\n\n file.puts \"==== DATA INVALID ====\"\n file.puts \"Skipping Invoice #{data[:invoice_num]} of company #{data[:company]}\"\n file.puts \"Reason - #{exception.message}\"\n end\n end",
"def rescue_action(exception)\n @message = exception.message\n @backtrace = exception.backtrace.join(\"\\n\") unless exception.nil?\n logger.info @message\n logger.info @backtrace\n render :file => \"#{RAILS_ROOT}/app/views/errors/error.rhtml\", :layout=> false, :status => 404\n end",
"def render_backtrace(exception)\n return unless Rails.application.config.consider_all_requests_local\n backtrace = Rails.backtrace_cleaner.filter(exception.backtrace).first(10)\n backtrace << '...'\n backtrace.join(\"\\n\")\n end",
"def error(msg); @logger.error(msg); end",
"def log_error(exception, raised_on)\n current_user_string = \"\"\n current_user_string = (\", User ID: \" + @current_user.id.to_s) if @current_user\n logger.error \"\\n!!!!!!!!!!!!!!!!!! ERROR BEGINS !!!!!!!!!!!!!!!!!!!!!!\"\n logger.error exception\n logger.error (\"Raised on: \" + raised_on + current_user_string + \"\\n\")\n end",
"def amf_exception_handler(ex)\n RAILS_DEFAULT_LOGGER.error ex.message\n RAILS_DEFAULT_LOGGER.error ex.backtrace.join( \"\\n\" )\n render :amf => FaultObject.new(ex.to_s) if is_amf\n end",
"def exc_msg_and_response(exc, response = T.unsafe(nil)); end",
"def err(e)\n @logger.error(e)\n end",
"def record_exception(exception, record_error=true)\n set_tag(:error, true) if record_error\n set_tag(:'sfx.error.kind', exception.class.to_s) \n set_tag(:'sfx.error.message', exception.message)\n if not exception.backtrace.nil?\n set_tag(:'sfx.error.stack', exception.backtrace.join('\\n'))\n end\n end",
"def render_error(exception)\n # use the exception_notifier gem to send out an e-mail to the notification list specified in config/environment.rb\n ExceptionNotifier.notify_exception(exception)\n\n #TODO: hide stack traces from students after the beta. leave @error undefined to hide stack traces\n @error = exception\n\n render \"home/error\"\n end",
"def get_errors exception\n puts exception\n puts exception.backtrace\n Rails.logger.error(exception)\n\n @error_title = I18n.t 'errors.get_errors.title', default: 'Get An Error!'\n @error_message = I18n.t 'errors.get_errors.message', default: 'The operation you did get an error'\n render :template => '/errors/error_page',layout: false\n end",
"def log_error(err)\n\t\tprint_error(err)\n\n\t\twlog(err)\n\n\t\t# If it's a syntax error, log the call stack that it originated from.\n\t\tdlog(\"Call stack:\\n#{$@.join(\"\\n\")}\", 'core', LEV_1)\n\tend",
"def send(method, *args)\n super\n rescue StandardError => e\n args[1].debug \"#{e}\\n #{e.backtrace.first}\" # args[1] is the logger\n end",
"def setup_exception_context(ex, _pry_, options={})\n _pry_.last_exception = ex \n _pry_.backtrace = (ex.backtrace || [])\n\n PryStackExplorer.frame_manager(_pry_).user[:exception] = ex\n PryStackExplorer.frame_manager(_pry_).user[:inline_exception] = !!options[:inline]\n end",
"def handle_error(error)\n puts error.message\n puts error.backtrace.join(\"\\n\")\n end",
"def debug_exception_response_format=(_arg0); end",
"def debug_exception_response_format=(_arg0); end",
"def error(ex) [:error, ex]; end",
"def log_exception(exception, request_data = nil,\n status_code = nil, error_messages = nil)\n msgs = []\n msgs << \"An exception was caught (#{exception.class.name}):\"\n\n if exception.respond_to?(:message)\n msgs << exception.message\n else\n msgs << exception.to_s\n end\n\n if error_messages.is_a?(Array)\n msgs.concat error_messages\n elsif !error_messages.nil? && !error_messages.empty?\n msgs << error_messages\n end\n\n unless request_data.blank?\n msgs << \"Request params were:\"\n msgs << request_data.inspect\n end\n unless status_code.blank?\n msgs << \"Handling with status code: #{status_code}\"\n end\n if exception.respond_to?(:backtrace) && !exception.backtrace.blank?\n msgs << exception.backtrace.join(\"\\n \")\n end\n\n log_error msgs\n end",
"def exception_logger(e)\n Rails.logger.error(\"\\n#{e.class} #{e.message} in #{e.backtrace.first}\")\n Rails.logger.error(e.backtrace[1..50].each { |l| l.gsub(/#{Rails.root.to_s}/, '') }.join(\"\\n\"))\n end",
"def display_error_message(ex)\n $stderr.puts self.to_s()\n super(ex) \n end",
"def parsing_error(data, exception)\n $stderr.puts \"parsing error:\\n#{exception.message}\"\n end",
"def error job, exception\n if tracetop = exception.backtrace&.first\n # Extract the file and line # from the stack top\n tracetop = \" at<br>\" + tracetop.match(/(.*:[\\d]*)/).to_s.if_present || tracetop\n tracetop.sub! Rails.root.to_s+'/', ''\n end\n errors.add :base, exception.to_s+tracetop\n self.status = :bad if processing? # ...thus allowing others to set the status\n end",
"def log_errors!\n if AnyCable.config.debug?\n # Print error with backtrace in debug mode\n AnyCable.capture_exception do |e|\n stack = e.backtrace\n backtrace = stack ? \":\\n#{stack.take(20).join(\"\\n\")}\" : \"\"\n AnyCable.logger.error(\"#{e.message}#{backtrace}\")\n end\n else\n AnyCable.capture_exception { |e| AnyCable.logger.error(e.message) }\n end\n end",
"def error(msg, exc: -1, silent: false)\n tell \"#{✘} {r{#{msg}}}\" unless silent\n\n if exc.is_a? Integer\n exit exc\n elsif !exc.nil?\n raise exc if msg.nil?\n raise exc, msg\n end\n end",
"def error(exception)\n logger.info \"execution failed: #{exception}\"\n end",
"def error(exception)\n logger.error \"Beetle: handler execution raised an exception: #{exception.class}(#{exception.message})\"\n end",
"def log_error(*error_messages)\r\n options = custom_infos.extract_options!\r\n\r\n infos = []\r\n infos << \"Non-Exception Error raised when executing #{request.method} #{request.fullpath}\" if defined? request\r\n error_messages.each do |e_message|\r\n infos << \"\\t#{e_message}\"\r\n end\r\n infos << \"Error trace:\"\r\n include_trace_to info\r\n infos << \"\\n\"\r\n\r\n if options[:write_to] && options[:write_to].to_sym == :info\r\n $arb_log.error infos.join(\"\\n\")\r\n else\r\n $log.error infos.join(\"\\n\")\r\n end\r\nend",
"def formatted\n message = \"\\n#{@exception.class}: #{@exception.message}\\n \"\n message << @exception.backtrace.join(\"\\n \")\n message << \"\\n\\n\"\n end",
"def handle_stub_log_error(exception_data, always_raise = false)\n raise_unexpected_exception(exception_data) if always_raise || !exception_filtered?(exception_data)\n end",
"def display_error_message(ex)\n $stderr.puts \"#{name} aborted!\"\n $stderr.puts ex.message\n if options.trace\n $stderr.puts ex.backtrace.join(\"\\n\")\n else\n $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || \"\"\n $stderr.puts \"(See full trace by running task with --trace)\"\n end\n end",
"def log_error(err)\n backtrace = Array(err.backtrace).flatten.compact\n\n backtrace =\n if backtrace.empty?\n ''\n else\n prefix = \"\\n \"\n prefix + backtrace.join(prefix)\n end\n\n message = \"#{err.class}: #{err.message}#{backtrace}\"\n Fluffle.logger.error message\n end",
"def log_exception(exception, extra = {})\n process_exception(exception, extra: extra)\n end",
"def error e\n log(\"ERREUR: #{e.message}\")\n log(\"BACKTRACE ERREUR: #{e.backtrace.join(\"\\n\")}\")\n self << {error: e.message, backtrace: e.backtrace}\n end",
"def error_log\n end",
"def error_log\n end",
"def error_log\n end",
"def log_exception(where, e)\n logger.error \"#{where}: #{e.class}: #{e.message}\\n#{e.backtrace.join(\"\\n\")}\"\n end",
"def log_error(exception) #:doc:\n ActiveSupport::Deprecation.silence do\n if ActionView::TemplateError === exception\n logger.fatal(exception.to_s)\n else\n logger.fatal(\n \"\\n#{exception.class} (#{exception.message}):\\n \" +\n clean_backtrace(exception).join(\"\\n \") + \"\\n\\n\"\n )\n end\n end\n end",
"def display_error_message(ex)\n $stderr.puts \"#{name} aborted!\"\n $stderr.puts ex.message\n if options.trace\n $stderr.puts ex.backtrace.join(\"\\n\")\n else\n $stderr.puts tdp_file_location(ex.backtrace)\n end\n $stderr.puts \"(See full trace by running task with --trace)\" unless options.trace\n end",
"def log_exception(level, e, backtrace_level = level)\n @log.send(level, '%p: %s' % [e.class, e.message])\n @log.send(backtrace_level) do\n backtrace = backtrace_from_exception(e)\n if backtrace\n \"Debugging backtrace:\\n\" + backtrace.join(\"\\n \")\n else\n 'No backtrace available.'\n end\n end\n end",
"def log_errors!\n if AnyCable.config.debug?\n # Print error with backtrace in debug mode\n AnyCable.capture_exception do |e|\n AnyCable.logger.error(\"#{e.message}:\\n#{e.backtrace.take(20).join(\"\\n\")}\")\n end\n else\n AnyCable.capture_exception { |e| AnyCable.logger.error(e.message) }\n end\n end",
"def exception(ex)\n update_result(Automation::Result::Exception)\n @logger.error(format_exception(ex))\n end",
"def handle_exception(data)\n logger.warn \"Got exception from remote call of #{data[\"action\"]}: #{data[\"message\"]}\"\n end",
"def error exception, req, res\n backtrace = exception.backtrace.join \"\\n\"\n\n res.content_type = 'text/html'\n res.status = 500\n res.body = <<-BODY\n<!DOCTYPE html>\n<html>\n<head>\n<meta content=\"text/html; charset=UTF-8\" http-equiv=\"Content-Type\">\n\n<title>Error - #{ERB::Util.html_escape exception.class}</title>\n\n<link type=\"text/css\" media=\"screen\" href=\"#{@mount_path}/css/rdoc.css\" rel=\"stylesheet\">\n</head>\n<body>\n<h1>Error</h1>\n\n<p>While processing <code>#{ERB::Util.html_escape req.request_uri}</code> the\nRDoc (#{ERB::Util.html_escape RDoc::VERSION}) server has encountered a\n<code>#{ERB::Util.html_escape exception.class}</code>\nexception:\n\n<pre>#{ERB::Util.html_escape exception.message}</pre>\n\n<p>Please report this to the\n<a href=\"https://github.com/ruby/rdoc/issues\">RDoc issues tracker</a>. Please\ninclude the RDoc version, the URI above and exception class, message and\nbacktrace. If you're viewing a gem's documentation, include the gem name and\nversion. If you're viewing Ruby's documentation, include the version of ruby.\n\n<p>Backtrace:\n\n<pre>#{ERB::Util.html_escape backtrace}</pre>\n\n</body>\n</html>\n BODY\n end",
"def handle_exception(exception, options = {})\n request = options[:request]\n render_errors = options[:render_errors] || false\n proc_name = options[:proc_name] || config[:app_name]\n error_messages = options[:error_messages] || ['']\n\n error_messages = [error_messages] unless error_messages.is_a?(Array)\n\n if exception.respond_to?(:backtrace)\n backtrace = exception.backtrace\n else\n backtrace = caller\n end\n\n # extract the relevant request data and also filter out any params\n # that should NOT be logged/emailed (passwords etc.)\n request_data = request_data_from_request(request) unless request.nil?\n\n supplementary_info = nil\n\n unless config[:call_for_supplementary_info].nil?\n supplementary_info = config[:call_for_supplementary_info].call(request)\n supplementary_info = [supplementary_info] unless supplementary_info.is_a?(Array)\n end\n\n unless supplementary_info.blank?\n error_messages << \"Supplementary info:\"\n error_messages += supplementary_info\n end\n\n if exception.nil?\n exception_classname = nil\n status_code = nil\n log_error error_messages.inspect\n log_error backtrace\n log_error \"Request params were:\"\n log_error request_data.to_yaml\n error_string = error_messages.shift\n else\n status_code =\n Wrangler::ExceptionHandler.status_code_for_exception(exception)\n\n log_exception(exception, request_data, status_code, error_messages)\n\n if exception.is_a?(Class)\n exception_classname = exception.name\n else\n exception_classname = exception.class.name\n end\n\n if exception.respond_to?(:message)\n error_string = exception.message\n else\n error_string = exception.to_s\n end\n end\n\n if send_notification?(exception, request, status_code)\n if notify_with_delayed_job?\n # don't pass in request as it contains not-easily-serializable stuff\n log_error \"Wrangler sending email notification asynchronously\"\n Wrangler::ExceptionNotifier.send_later(:deliver_exception_notification,\n exception_classname,\n error_string,\n error_messages,\n proc_name,\n backtrace,\n supplementary_info,\n status_code,\n request_data)\n else\n log_error \"Wrangler sending email notification synchronously\"\n Wrangler::ExceptionNotifier.deliver_exception_notification(exception_classname,\n error_string,\n error_messages,\n proc_name,\n backtrace,\n supplementary_info,\n status_code,\n request_data,\n request)\n end\n end\n\n if render_errors\n render_error_template(exception, status_code)\n end\n\n rescue Exception => unhandled_exception\n # if it looks like a temporary error interacting with SMTP, then enqueue\n # the error using delayed job if possible\n # (testing by name this way in case the exception isn't loaded into\n # environment, which would cause a NameError and be counterproductive...)\n if unhandled_exception.class.name == 'Net::SMTPAuthenticationError' &&\n Wrangler::ExceptionNotifier.respond_to?(:send_later)\n\n log_error \"Wrangler failed to send error notification: #{unhandled_exception.class.name}:\"\n log_error \" #{unhandled_exception.to_s}\"\n\n # note: this is specific to an old-ish version of delayed job...should\n # make wrangler compatible with the old and the new...\n log_error \"Wrangler attempting to send via delayed job\"\n Wrangler::ExceptionNotifier.send_later(:deliver_exception_notification,\n exception_classname,\n error_string,\n error_messages,\n proc_name,\n backtrace,\n supplementary_info,\n status_code,\n request_data)\n else\n log_error \"/!\\\\ FAILSAFE /!\\\\ Wrangler encountered an unhandled exception \" +\n \"while trying to handle an error. The arguments it received \" +\n \"were:\"\n log_error \" exception: #{exception.inspect}\"\n log_error \" options: #{options.inspect}\"\n log_error \"The unhandled error encountered was #{unhandled_exception.class.name}:\"\n log_error \" #{unhandled_exception.to_s}\"\n end\n end",
"def log_error(exception) #:doc:\n ActiveSupport::Deprecation.silence do\n if ActionView::TemplateError === exception\n logger.fatal(exception.to_s)\n else\n logger.fatal(\n \"\\n\\n#{exception.class} (#{exception.message}):\\n \" +\n clean_backtrace(exception).join(\"\\n \") +\n \"\\n\\n\"\n )\n end\n end\n end",
"def raiseError(msg)\n\t\tputs msg\n\t\t@src = []\n\t\t@expected_indent = 0\n\tend",
"def render_error exception\n\n logger.info\"==========error 500=========\"\n #Rails.logger.error(exception)\n #render :template => \"/errors/500.html.erb\", :status => 500\n logger.info \"#{'-'*100} #{request.format} #{'-'*100}\"\n @error = exception\n ActiveSupport::Notifications.instrument \"exception.action_controller\", message: @error.message, inspect: @error.inspect, backtrace: @error.backtrace\n respond_to do |format|\n format.html { render template: \"errors/error_500\", status: 500, layout:false }\n format.all { render nothing: true, status: 500}\n\n end\n log_exception_handler(exception)\n end",
"def write_error_info\n end"
] |
[
"0.6682094",
"0.6382295",
"0.63343036",
"0.61962634",
"0.6130218",
"0.6102125",
"0.6064013",
"0.602026",
"0.5987188",
"0.5961902",
"0.59611785",
"0.59099096",
"0.5905247",
"0.58743876",
"0.5774503",
"0.5765145",
"0.57406294",
"0.57210904",
"0.57158697",
"0.5700352",
"0.5677045",
"0.5638979",
"0.5622637",
"0.5606167",
"0.5588847",
"0.5545495",
"0.5509568",
"0.55018675",
"0.5480462",
"0.5476181",
"0.5471324",
"0.5465252",
"0.5415396",
"0.5396837",
"0.539459",
"0.5393195",
"0.5392448",
"0.53414416",
"0.53414416",
"0.53358227",
"0.52995723",
"0.5247784",
"0.523974",
"0.52356094",
"0.5232331",
"0.52320606",
"0.52286136",
"0.52265066",
"0.52250695",
"0.5220338",
"0.5217105",
"0.5215328",
"0.52123713",
"0.5209884",
"0.51983136",
"0.51823115",
"0.5175584",
"0.5166228",
"0.51640195",
"0.51501626",
"0.5148718",
"0.51455",
"0.5141832",
"0.5137082",
"0.5133593",
"0.51301044",
"0.51301044",
"0.51291186",
"0.51197994",
"0.51156676",
"0.5113752",
"0.51026016",
"0.5095973",
"0.5079044",
"0.5076252",
"0.5070978",
"0.5070791",
"0.50593096",
"0.5058332",
"0.5057445",
"0.5057434",
"0.50573224",
"0.5047167",
"0.5046201",
"0.50433046",
"0.50433046",
"0.50433046",
"0.50313914",
"0.50273305",
"0.50172687",
"0.5015658",
"0.5014402",
"0.5011679",
"0.5008742",
"0.5006287",
"0.49971545",
"0.4992509",
"0.49912328",
"0.49862006",
"0.49808082"
] |
0.6421739
|
1
|
Warns that the Ruby environment does not support continuations. Applies to JRuby, Rubinius and MacRuby. This warning will only display once per Ruby process.
|
def warn_no_continuations
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def warn_no_continuations; end",
"def rubinius_skip(message = '')\n skip message if RUBY_ENGINE == 'rbx'\nend",
"def rubinius_skip(message = '')\n skip message if RUBY_ENGINE == 'rbx'\nend",
"def rubinius_skip(message = '')\n skip message if RUBY_ENGINE == 'rbx'\nend",
"def warn(progname = T.unsafe(nil), &block); end",
"def uncertain_exit_status?\n defined?(JRUBY_VERSION)\n end",
"def silence_single_worker_warning; end",
"def old_and_busted\n warn \"#old_and_busted is deprecated. Use #new_hotness instead.\"\n puts \"Hello, world\"\nend",
"def jruby_skip(message = '')\n skip message if defined?(JRUBY_VERSION)\nend",
"def jruby_skip(message = '')\n skip message if defined?(JRUBY_VERSION)\nend",
"def jruby_skip(message = '')\n skip message if defined?(JRUBY_VERSION)\nend",
"def sparkLogWarningToCerr(sync = false)\n sparkEnableLog(':cerr', 'eWarning', sync)\nend",
"def run_warned; end",
"def backtrace_ignores; end",
"def running_jruby_1_7_or_later\n RUBY_PLATFORM == 'java' && !JRUBY_VERSION.match(/[0-1]\\.[0-6]/)\nend",
"def skip_on(*engs, suffix: '', bt: caller)\n engs.each do |eng|\n skip_msg = case eng\n when :darwin then \"Skipped on darwin#{suffix}\" if RUBY_PLATFORM[/darwin/]\n when :jruby then \"Skipped on JRuby#{suffix}\" if Puma.jruby?\n when :truffleruby then \"Skipped on TruffleRuby#{suffix}\" if RUBY_ENGINE == \"truffleruby\"\n when :windows then \"Skipped on Windows#{suffix}\" if Puma.windows?\n when :ci then \"Skipped on ENV['CI']#{suffix}\" if ENV[\"CI\"]\n when :no_bundler then \"Skipped w/o Bundler#{suffix}\" if !defined?(Bundler)\n else false\n end\n skip skip_msg, bt if skip_msg\n end\n end",
"def warning(msg, ask_continue: true)\n tell(colorize(\"☞ \", :magenta) + colorize(msg, :yellow))\n exit(-1) if ask_continue && !quiz(\"continue\")\n end",
"def isolate_from_interrupts; end",
"def pre_restore_warning\n end",
"def silence_deprecations; end",
"def warning?; end",
"def warning?; end",
"def warning?; end",
"def skip30\n skip unless RUBY_VERSION > \"3.0\"\n end",
"def warn(*args)\n # eliminate ruby/gem warnings from output\nend",
"def xlate_flags()\n return(\"Abort\") if (flag_abort?)\n return(\"None\")\n end",
"def warned; end",
"def silence_warnings\n saved_verbosity = $-v\n $-v = nil\n yield\nensure\n $-v = saved_verbosity\nend",
"def silence_warnings\n old_verbose, $VERBOSE = $VERBOSE, nil\n yield\nensure\n $VERBOSE = old_verbose\nend",
"def silence_warnings\n old_verbose, $VERBOSE = $VERBOSE, nil\n yield\nensure\n $VERBOSE = old_verbose\nend",
"def ridicule_faultfully_prerevision()\n end",
"def jruby_skip(message = \"\")\n skip message if defined?(JRUBY_VERSION)\n end",
"def jruby_skip(message = \"\")\n skip message if defined?(JRUBY_VERSION)\n end",
"def complain_about_bad_flags!\n @complain_about_bad_flags = true\n end",
"def pour_bottle?\n quiet_system(\"/usr/libexec/java_home --version 1.8 --failfast\")\n end",
"def lwarn; end",
"def fatal?; end",
"def fatal?; end",
"def coredump?; false; end",
"def no_warn\n verbose = $VERBOSE\n $VERBOSE = nil\n yield\n ensure\n $VERBOSE = verbose\n end",
"def needs_syck?\n !LanguageSupport.using_engine?('jruby') &&\n LanguageSupport.using_version?('1.9.2')\n end",
"def ceiling_warning\n lint_length = (@output[:lint_errors].length + @output[:lint_warnings].length + @output[:lint_conventions].length + @output[:lint_refactors].length + @output[:lint_fatals].length)\n return unless lint_length > 100\n\n failed_task = @task.color(:green)\n errors = \"#{lint_length} failures.\".color(:red)\n errormsg = [\n \"You wouldn't stand a chance in Rome.\\nResolve thy errors and train with #{failed_task} again.\",\n \"The gods frown upon you, mortal.\\n#{failed_task}. Again.\",\n \"Do not embarrass the city. Fight another day. Use #{failed_task}.\",\n \"You are without honor. Replenish it with another #{failed_task}.\",\n \"You will never claim the throne with a performance like that.\",\n \"Pompeii has been lost.\",\n \"A wise choice. Do not be discouraged from another #{failed_task}.\"\n ].sample\n errormsg << \"\\n\\n\"\n\n go_on = prompt \"\\n#{errors} Continue? (y/n) \"\n abort errormsg unless truthy?(go_on)\n end",
"def jruby_excon_skip?\n defined?(JRUBY_VERSION) &&\n defined?(::Excon::VERSION) &&\n Gem::Version.new(::Excon::VERSION) < Gem::Version.new('0.20.0')\n end",
"def pre_run_check\n Puppet.warning(\"#{self[:name]}: Doing some pre-run checks\")\n binding.pry if defined?(Pry)\n end",
"def exit_still_pp\n end",
"def use_threads?\n !defined?(VCR)\n end",
"def warning! opts = nil\n NOCH.evaluate_for \"warning\", opts\n end",
"def coverage_exceeding_source_warn; end",
"def skip_unless(eng, bt: caller)\n skip_msg = case eng\n when :darwin then \"Skip unless darwin\" unless RUBY_PLATFORM[/darwin/]\n when :jruby then \"Skip unless JRuby\" unless Puma.jruby?\n when :windows then \"Skip unless Windows\" unless Puma.windows?\n when :mri then \"Skip unless MRI\" unless Puma.mri?\n else false\n end\n skip skip_msg, bt if skip_msg\n end",
"def silence_deprecations=(_arg0); end",
"def unicorn(why)\n puts why, \"Good job, rainbow kisses for you!!\"\n exit(0)\nend",
"def wrap_sync_load?\n ( !defined?( JRUBY_VERSION ) ||\n version_lt?( JRUBY_VERSION, [9] ) ||\n version_gte?( JRUBY_VERSION, [9,0,5] ) )\n end",
"def warning(msg, ask_continue: true)\n tell \"#{☞} {y{#{msg}}}\"\n exit(-1) if ask_continue && !ask(\"continue\")\n end",
"def without_warnings\n old_verbose = $VERBOSE\n begin\n $VERBOSE = nil\n yield\n ensure\n $-v = old_verbose\n end\n end",
"def gocdkit_warn(*message)\n unless ENV['GOCDKIT_SILENT']\n warn message\n end\n end",
"def with_repl_like_sigint; end",
"def disabled_warnings; end",
"def compilable?\n false\n end",
"def do_not_thread; true; end",
"def do_not_thread; true; end",
"def do_not_thread; true; end",
"def silently\n warn_level = $VERBOSE\n $VERBOSE = nil\n begin\n result = yield\n ensure\n $VERBOSE = warn_level\n end\n result\nend",
"def allow_concurrency; end",
"def allow_concurrency; end",
"def am_i_awesome?\n awesome = Proc.new do |version|\n case version\n when /1.9.?/ then true\n when \"1.8.7\" then false\n end\n end\n\n case RUBY_VERSION\n when awesome\n puts \"congrats, you're awesome\"\n else\n puts \"not really, you should: rvm install 1.9+\"\n end\nend",
"def language_aware!\n\t\traise_if_error C.glyr_opt_lang_aware_only(to_native, true)\n\tend",
"def flag_abort!\n if (!flag_abort?)\n @flags = @flags | TAC_PLUS_CONTINUE_FLAG_ABORT\n else\n @flags = @flags & (~TAC_PLUS_CONTINUE_FLAG_ABORT)\n end\n return(nil)\n end",
"def fatal; end",
"def abort ; conclude(false) ; end",
"def with_warnings(flag)\n old_verbose, $VERBOSE = $VERBOSE, flag\n yield\nensure\n $VERBOSE = old_verbose\nend",
"def backtrace_ignores=(_arg0); end",
"def calling_cry\n cry\n end",
"def no_language_aware!\n\t\traise_if_error C.glyr_opt_lang_aware_only(to_native, false)\n\tend",
"def check_for_implication_loops\n # actually this is tricky\n end",
"def fatal?\n false\n end",
"def octokit_warn(*message)\n unless ENV['OCTOKIT_SILENT']\n warn message\n end\n end",
"def raise_ruby_19_deprecation_warning!\n return unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')\n\n require 'ddtrace/patcher'\n\n Datadog::Patcher.do_once(:ruby_19_deprecation_warning) do\n Datadog::Tracer.log.warn(RUBY_19_DEPRECATION_WARNING)\n end\n end",
"def unboxed\n $stderr.puts \"I should never happen\"\n end",
"def skip_backtrace; end",
"def warn\n\n end",
"def warning(*args); end",
"def system_preferences_conflict!\n spinner.update title: Pastel.new.yellow(\"#{good} (please quit System Preferences first)\")\n spinner.stop\n end",
"def install_unhandled_exception_hook!\n # only install the hook once, even when called from multiple locations\n return if @unhandled_exception_hook_installed\n\n # the $! is set when the interpreter is exiting due to an exception\n at_exit do\n boom = $!\n if boom && !raise_errors? && !boom.is_a?(SystemExit)\n report(boom, 'argv' => ([$0]+ARGV).join(\" \"), 'halting' => true)\n end\n end\n\n @unhandled_exception_hook_installed = true\n end",
"def inhibit_all_warnings!\n current_target_definition.inhibit_all_warnings = true\n end",
"def enable_warnings\n with_warnings(true) { yield }\n end",
"def chrome_conflict!\n spinner.update title: Pastel.new.yellow(\"#{good} (please quit Chrome first)\")\n spinner.stop\n end",
"def faint; end",
"def faint; end",
"def non_interactive_mode(_pry_)\n _pry_.print = proc {}\n _pry_.exception_handler = proc do |o, e, _pry_|\n _pry_.run_command \"cat --ex\"\n o.puts \"...exception encountered, going interactive!\"\n interactive_mode(_pry_)\n end\n end",
"def silence_warnings\n yield\nend",
"def compile\n return if changed_ruby_files.empty?\n\n errors = changed_ruby_files.each_with_object([]) do |file, es|\n output = `ruby -cw \"#{file}\" 2>&1`\n next if output == \"Syntax OK\\n\"\n\n es << output\n end\n heading('Ruby Warnings', errors.join) unless errors.empty?\n end",
"def continue?; end",
"def flag_abort?()\n return(true) if(@flags & TAC_PLUS_CONTINUE_FLAG_ABORT == TAC_PLUS_CONTINUE_FLAG_ABORT)\n return(false)\n end",
"def default_force_ruby_platform\n return false unless RUBY_ENGINE == \"truffleruby\"\n\n !Gem::Platform::REUSE_AS_BINARY_ON_TRUFFLERUBY.include?(name)\n end",
"def without_bindings_below_raise(bindings); end",
"def without_stderr; end",
"def legacy_mode?\n return true if RUBY_VERSION.match(/1\\.8\\.[67]/)\n end",
"def force_analysis\n false\n end",
"def force_analysis\n false\n end",
"def double_corruption_slider!\n warn \"Disabled code #{__method__}. Do not enable in release. #{__FILE__}:#{__LINE__}\"\n\n soft_patch_defines_lua!(\"fun_and_balance_corruption\",\n [\"NCountry.CORRUPTION_COST\", 0.05, 0.10],\n )\n patch_mod_file!(\"common/static_modifiers/00_static_modifiers.txt\") do |node|\n node[\"root_out_corruption\"][\"yearly_corruption\"] = -2.0\n end\n end"
] |
[
"0.7130728",
"0.5488456",
"0.5488456",
"0.5488456",
"0.5397916",
"0.53552765",
"0.5345994",
"0.5299118",
"0.5293796",
"0.5293796",
"0.5293796",
"0.5215354",
"0.5186471",
"0.5135099",
"0.5126447",
"0.50751024",
"0.506705",
"0.5034577",
"0.49753577",
"0.49483946",
"0.49292287",
"0.49292287",
"0.49292287",
"0.49132535",
"0.4912573",
"0.49098635",
"0.4905133",
"0.49028176",
"0.4897954",
"0.4897954",
"0.48931944",
"0.48909107",
"0.48909107",
"0.48899302",
"0.48835388",
"0.48687357",
"0.4856028",
"0.4856028",
"0.48457152",
"0.48451477",
"0.48384959",
"0.48369408",
"0.48325142",
"0.48276344",
"0.48262978",
"0.48152143",
"0.4811609",
"0.48023772",
"0.48015854",
"0.4778241",
"0.47742063",
"0.4773125",
"0.4751772",
"0.474329",
"0.4734771",
"0.47333023",
"0.4732012",
"0.47247976",
"0.47246113",
"0.47246113",
"0.47246113",
"0.4724036",
"0.4723779",
"0.4723779",
"0.47236305",
"0.47137767",
"0.470294",
"0.469495",
"0.46944493",
"0.46903473",
"0.46888208",
"0.46825364",
"0.46717742",
"0.46688884",
"0.46539444",
"0.4638069",
"0.46334016",
"0.4625256",
"0.46135822",
"0.46111977",
"0.4609183",
"0.46073103",
"0.46006817",
"0.46000797",
"0.45974416",
"0.459566",
"0.45903465",
"0.45903465",
"0.45885858",
"0.4573",
"0.4570939",
"0.45703894",
"0.45650154",
"0.4564119",
"0.4553592",
"0.45518428",
"0.4551842",
"0.45460632",
"0.45460632",
"0.4545394"
] |
0.70627606
|
1
|
Sets the logger level for the duration of the block
|
def enter_level(new_level = level)
old_level = level
self.level = new_level
yield
ensure
self.level = old_level
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def level=(level)\n logger.level = level\n end",
"def log_level=(level); end",
"def log_level=(level)\n logger.level = level\n end",
"def level=(level)\n @level = level\n @log.level = @level\n end",
"def log_level=(level)\n @logger.level = level\n end",
"def log_level=(value)\n logger.level = value\n end",
"def log_level=(value)\n logger.level = value\n end",
"def log_level=(value)\n logger.level = value\n end",
"def loglevel=(level)\n @loglevel = logger.level = level\n end",
"def set_level(level)\n Merb::Config[:log_level] = level\n Merb.reset_logger!\n end",
"def loglevel=(level)\n @log.level=level\n end",
"def log_level=(val)\n @@log_level = val\n end",
"def log_at(level)\n old_local_level, self.local_level = local_level, level\n yield\n ensure\n self.local_level = old_local_level\n end",
"def set_level(level)\n if SEVERITY.has_key? level\n @log_level=level\n else\n raise ArgumentError, \"Invalid log level given\"\n end\n end",
"def level=(log_level)\n @@log_level = DEBUG_LEVEL[log_level]\n end",
"def log_with( &block )\n @logger = block\n end",
"def level=(value)\n logger_instance.level = self.class.level_from_any(value)\n end",
"def log(bar, level = Logger::INFO, &block)\n raise 'No block provided' unless block_given?\n raise \"Invalid level '#{level}'\" unless logger.respond_to? level\n\n bar.clear\n @logger.public_send(level, self.class, &block)\n bar.refresh(force: true) unless bar.stopped?\n nil\n end",
"def log_level=(level)\n writer.level = level if level.is_a?(Integer) && level.between?(0, 3)\n writer.level = LOG_LEVELS[level] ||\n raise(ArgumentError, \"unknown log level\")\n @level = level\n end",
"def level=(new_level)\n @logger.level=Logger::Severity.const_get(new_level.to_sym.upcase)\n end",
"def level=(new_level)\n logger.level = severity_lookup(new_level, :info)\n end",
"def level=(level)\n init unless @initialized\n unless @level_frozen\n new_level = case level\n when Symbol then level_from_sym(level)\n when String then level_from_sym(level.to_sym)\n else level\n end\n if new_level != @level\n @logger.info(\"[setup] setting log level to #{level_to_sym(new_level).to_s.upcase}\")\n @logger.level = @level = new_level\n end\n end\n level = level_to_sym(@level)\n end",
"def level; @logger.level; end",
"def with_logging level = Logger::DEBUG\n original_level = Accessibility.log.level\n Accessibility.log.level = level\n yield\n Accessibility.log.level = original_level\n end",
"def level=(level)\n @level = level.to_s.downcase.to_sym\n\n loggers.each do |_, logger|\n logger.level = @level\n end\n\n @level\n end",
"def log_level=(level)\n\t if level == 'debug'\n\t\t\t@log.level = Logger::DEBUG\n\t\telsif level == 'info'\n\t\t\t@log.level = Logger::INFO\n\t\telsif level == 'warn'\n\t\t\t@log.level = Logger::WARN\n\t\telsif level == 'error'\n\t\t\t@log.level = Logger::ERROR\n\t\telsif level == 'fatal'\n\t\t\t@log.level = Logger::FATAL\n\t\tend\n\tend",
"def log_level=(level)\n\t if level == 'debug'\n\t\t\t@log.level = Logger::DEBUG\n\t\telsif level == 'info'\n\t\t\t@log.level = Logger::INFO\n\t\telsif level == 'warn'\n\t\t\t@log.level = Logger::WARN\n\t\telsif level == 'error'\n\t\t\t@log.level = Logger::ERROR\n\t\telsif level == 'fatal'\n\t\t\t@log.level = Logger::FATAL\n\t\tend\n\tend",
"def set_logger(logger, level)\n @debug_level = level.to_i\n @logger=logger\n end",
"def log_level=(_arg0); end",
"def log_level=(_arg0); end",
"def setlog(level)\n $LOGLEVEL = level\n end",
"def log_set (level)\n execute(:log_set, level)\n end",
"def logger_level; end",
"def level=(val)\n # Convert strings to the constant value\n val = convert_level(val)\n\n # Update the default log level\n @default_level = val\n\n # Set all loggers' log levels\n @loggers.each do |key, logger|\n logger.level = val\n end\n end",
"def log_level=(log_level)\n @log_level = log_level if [DEBUG, INFO, WARN, ERROR].include?(log_level)\n end",
"def level=(value)\n @loggers.each do |logger|\n logger.level = value if logger.respond_to?(:level=)\n end\n end",
"def loglevel= level\n self.class.createlogger unless self.class._logobject\n level = level.to_s.downcase.to_sym\n unless JLogger::Simple::LEVELS.has_key? level\n raise ArgumentError, \"'#{level}' is an invalid loglevel\"\n end\n \n self.class._logobject.level = JLogger::Simple::LEVELS[level]\n end",
"def level(l)\n @config[:level] = l\n end",
"def logging_level=(level)\n level = Integer(level)\n raise ArgumentError, \"invalid logging level value #{level}\" if level < 1\n @logging_level = level\n end",
"def set_log_level(log_level)\n case log_level.downcase\n when 'debug'\n @logger.level = Logger::DEBUG\n when 'info'\n @logger.level = Logger::INFO\n when 'warn'\n @logger.level = Logger::WARN\n when 'error'\n @logger.level = Logger::ERROR\n when 'fatal'\n @logger.level = Logger::FATAL\n end\n end",
"def severity= severity\n @logger.level = severity\n end",
"def logBlock(message, level, component, block)\n @logger.block(\n message, level: Logging::Writer::LEVEL_TO_TYPE[level],\n component: component\n ) do\n block.apply\n end\n end",
"def log_level(level)\n\t\t\t@sys_lock.synchronize {\n\t\t\t\t@log_level = Control::get_log_level(level)\n\t\t\t\tif @controller.active\n\t\t\t\t\t@logger.level = @log_level\n\t\t\t\tend\n\t\t\t}\n\t\tend",
"def log_level(value)\n Logger.log_level = value\n return nil\n end",
"def silence(temporary_level = Logger::ERROR)\n old_logger_level = @level\n @level = temporary_level \n yield\n ensure\n @level = old_logger_level\n end",
"def log_level; end",
"def log_level; end",
"def log_level level\n level = Deployable::Logger.const_get level.upcase unless \n level.kind_of? ::Fixnum\n\n @log.level = level\n end",
"def set_log_level( level )\n case level\n when :fatal\n ::Logger::FATAL\n when :error\n ::Logger::ERROR\n when :warn\n ::Logger::WARN\n when :info\n ::Logger::INFO\n when :debug\n ::Logger::DEBUG\n else\n ::Logger::INFO\n end\n end",
"def silence(temporary_level = Logger::ERROR)\n old_logger_level = @level\n @level = temporary_level\n yield\n ensure\n @level = old_logger_level\n end",
"def log_level\n @log_level ||= DEFAULT_LOG_LEVEL\n end",
"def log_level\n @log_level ||= DEFAULT_LOG_LEVEL\n end",
"def set_logging_level(level)\n level = level.to_s.downcase\n if %w[debug info warn error fatal unknown].include?(level)\n @logger.level = level.to_sym\n else\n @logger.warn('Invalid logger level')\n end\n end",
"def level\n logger.level\n end",
"def level=(level) # needed to meet the Sentry spec\n @level = level.to_s == \"warn\" ? :warning : level\n end",
"def mute_logger\n zk_log = Logging.logger['ZK']\n orig_level, zk_log.level = zk_log.level, :off\n orig_zk_level, Zookeeper.debug_level = Zookeeper.debug_level, Zookeeper::Constants::ZOO_LOG_LEVEL_ERROR\n yield\n ensure\n zk_log.level = orig_zk_level\n end",
"def setLogger(log_file, level = :info)\n $logger = Lumberjack::Logger.new(log_file.to_s, buffer_size: 0) # Open a new log file with INFO level\n $logger.level = level\n puts \"#{level} logging to #{log_file}\"\nend",
"def error_level=(level)\n\t\t\t@stderr_logger.level = level\n\t\tend",
"def error_level=(level)\n\t\t\t@stderr_logger.level = level\n\t\tend",
"def silence\n old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger\n yield\n ensure\n logger.level = old_logger_level if logger\n end",
"def mute_logger\n zk_log = Zookeeper::Logger.wrapped_logger\n\n orig_level, zk_log.level = zk_log.level, ::Logger::FATAL\n orig_zk_level, Zookeeper.debug_level = Zookeeper.debug_level, Zookeeper::Constants::ZOO_LOG_LEVEL_ERROR\n yield\n ensure\n zk_log.level = orig_zk_level\n end",
"def level=(level)\n if (level < 2)\n Logger.log_internal(4) do \"PubOutputter: Can't allow log level to be set to DEBUG\" end\n level = 2\n end\n super\n end",
"def logger=(logger); end",
"def logger=(logger); end",
"def silence\n old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger\n yield\n ensure\n logger.level = old_logger_level if logger\n end",
"def log_level\n @log_level ||= :debug\n end",
"def log_level\n @log_level ||= :debug\n end",
"def silence\n old_logger_level, logger.level = logger.level, Logger::ERROR if logger\n yield\n ensure\n logger.level = old_logger_level if logger\n end",
"def set_log_level(level=nil)\n defined?(Rails) and (default = (Rails.env.production? ? \"INFO\" : \"DEBUG\")) or (default = \"INFO\")\n log_level = (ENV['LOG_LEVEL'] || level || default)\n self.level = ZTK::Logger.const_get(log_level.to_s.upcase)\n end",
"def direct_log(log_level, &blocK)\n @config.ui.logger.nil? and raise BaseError, \"You must supply a logger for direct logging support!\"\n\n if !block_given?\n log_and_raise(BaseError, \"You must supply a block to the log method!\")\n elsif (@config.ui.logger.level <= ZTK::Logger.const_get(log_level.to_s.upcase))\n if @config.ui.logger.respond_to?(:logdev)\n @config.ui.logger.logdev.write(ZTK::ANSI.uncolor(yield))\n @config.ui.logger.logdev.respond_to?(:flush) and @config.ui.logger.logdev.flush\n else\n @config.ui.logger.instance_variable_get(:@logdev).instance_variable_get(:@dev).write(ZTK::ANSI.uncolor(yield))\n @config.ui.logger.instance_variable_get(:@logdev).instance_variable_get(:@dev).respond_to?(:flush) and @config.ui.logger.instance_variable_get(:@logdev).instance_variable_get(:@dev).flush\n end\n end\n end",
"def level=(value)\n @level = ::Logger::Severity.const_get(value.to_s.upcase)\n end",
"def level\n logger_instance.level\n end",
"def set_log_level\n logger.level = options[:quiet] ? Logger::FATAL : Logger::WARN\n logger.level = Logger::INFO if options[:verbose]\n logger.info(\"Logger.level set to #{logger.level}\")\n raise OptionsError.new(\"Option mismatch - you can't provide -v and -q at the same time\") if options[:quiet] && options[:verbose]\n end",
"def level=(val)\n unless LEVELS.include?(val)\n fail \"Unknown log level, valid values are: #{LEVELS}\"\n end\n\n # Map the log4r levels to our simplified 3 level system\n # log4r level order is DEBUG < INFO < WARN < ERROR < FATAL\n case val\n when :normal\n # Output everything except debug statements\n console.level = Logger::INFO\n # Output everything\n log_files(:level=, Logger::DEBUG) unless console_only?\n when :verbose\n console.level = Logger::DEBUG\n log_files(:level=, Logger::DEBUG) unless console_only?\n when :silent\n # We don't use any fatal messages, so this is effectively OFF\n console.level = Logger::FATAL\n log_files(:level=, Logger::DEBUG) unless console_only?\n end\n\n @level = val\n end",
"def log=(logger); end",
"def level= severity\n new_level = derive_severity severity\n fail ArgumentError, \"invalid log level: #{severity}\" if new_level.nil?\n @level = new_level\n end",
"def option_logging\n block = proc { |level| Logging::Logger.root.level = level; propagate_option('--logging', level) }\n @cl_parser.on('--logging LEVEL', 'Specify the minimum log level that should be logged.', &block)\n end",
"def set_level(name, level=nil)\n # Default\n unless level then\n level = name\n name = nil\n end\n\n # Look up the level if the user provided a :symbol or \"string\"\n level = MultiLog.string_to_level(level.to_s) unless level.is_a? Fixnum\n\n if name\n # Set a specific one\n raise \"No log by the name '#{name}'\" unless @logdevs[name]\n @logdevs[name][:level] = level\n else\n # Set them all by default \n @logdevs.each{|_, logdev| logdev[:level] = level }\n end\n end",
"def log level, message; write level, message, caller[0] unless level > @level end",
"def loglevel\n @loglevel ||= ::Logger::WARN\n end",
"def with_error_log_level(level, &block)\n previous_level, @error_log_level = @error_log_level, level\n return yield\n ensure\n @error_log_level = previous_level\n end",
"def configure_logging(loglevel)\n return if loglevel == :none\n if self.options[:log_file].nil?\n\tKitchenplan::Log.init(Kitchenplan::Log::MultiIO.new(STDOUT))\n else\n\tfile = File.open(options[:log_file],\"a\")\n\tKitchenplan::Log.init(Kitchenplan::Log::MultiIO.new(STDOUT,file))\n end\n Kitchenplan::Log.level = loglevel\n end",
"def logger=(writer); end",
"def logger=(writer); end",
"def logger=(writer); end",
"def logger=(writer); end",
"def logger=(writer); end",
"def level=(severity)\n raise TypeError, \"invalid log level: #{severity}\" if !severity.is_a? Integer\n @level = severity\n end",
"def logger_level=(level)\n ::Mongo::Logger.logger.level = case level\n when :debug\n ::Logger::DEBUG\n when :fatal\n ::Logger::FATAL\n else\n nil\n end\n end",
"def level=(new_level)\n @level = LEVELS[new_level.to_sym]\n reset_methods(:close)\n end",
"def logger=(v)\n @@logger = v\n end",
"def set_log_level(logger, config)\n log_level = get_log_level(config)\n logger.level = log_level\n return logger\n end",
"def log_level(value, options = {})\n DuckMap::Logger.log_level = value\n if options.has_key?(:full)\n DuckMap.logger.full_exception = options[:full]\n end\n end",
"def log_internal(level=1)\n internal = Logger['log4r']\n return if internal.nil?\n internal.send(LNAMES[level].downcase, yield)\n end",
"def configure_logging(logger)\n logger.level = LOG_LEVEL\n logger.datetime_format = '%Y-%m-%d %H:%M:%S'\n logger.formatter = proc do |severity, datetime, progname, msg|\n color = case severity\n when \"DEBUG\" then :light_white\n when \"INFO\" then :light_yellow\n when \"WARN\" then :light_red\n when \"ERROR\" then :blue\n when \"FATAL\" then :magenta\n when \"UNKNOWN\" then :cyan\n end\n \"#{datetime}: #{msg.colorize(color)}\\n\"\n end\n logger\nend",
"def level\n @log.level\n end",
"def irc_log_level=(level)\n set(:irc_log_level, MonoLogger.const_get(level))\n if self.log\n self.log.level = self.irc_log_level\n end\n end",
"def log level, message\n logger.send(level, name) { message }\n end",
"def log level, message\n logger.send(level, name) { message }\n end",
"def logger=(logr); @logger = logr end",
"def discreet_output(&block)\n ll = self.logger.level\n self.logger.level = Capistrano::Logger::INFO \n yield\n self.logger.level = ll\nend"
] |
[
"0.73622376",
"0.72888374",
"0.7279045",
"0.7187214",
"0.71639913",
"0.71154404",
"0.71154106",
"0.71154106",
"0.7100337",
"0.69813406",
"0.68378246",
"0.67927706",
"0.67653644",
"0.6710115",
"0.66007537",
"0.6577039",
"0.653901",
"0.65349805",
"0.6527687",
"0.6469205",
"0.6453622",
"0.644445",
"0.6399857",
"0.6378484",
"0.63718736",
"0.63716465",
"0.63716465",
"0.63549536",
"0.6347596",
"0.6347596",
"0.634514",
"0.6344442",
"0.63345045",
"0.62945044",
"0.6270901",
"0.6262532",
"0.6259449",
"0.6163533",
"0.61540836",
"0.6151198",
"0.6148371",
"0.61455345",
"0.6117238",
"0.6113313",
"0.6035504",
"0.599912",
"0.599912",
"0.59985626",
"0.59881866",
"0.59876496",
"0.5984616",
"0.5984616",
"0.596767",
"0.59655446",
"0.59531826",
"0.594987",
"0.5949295",
"0.5943917",
"0.5943917",
"0.59394723",
"0.5937163",
"0.59363025",
"0.59277344",
"0.59277344",
"0.5920334",
"0.59113055",
"0.59113055",
"0.5910963",
"0.58924544",
"0.5872885",
"0.5861309",
"0.58558583",
"0.5854591",
"0.58507705",
"0.5843375",
"0.5833131",
"0.581456",
"0.57949275",
"0.57779646",
"0.575994",
"0.57401806",
"0.5739174",
"0.57346344",
"0.57346344",
"0.57346344",
"0.57346344",
"0.57346344",
"0.5707399",
"0.5676549",
"0.56531304",
"0.5638988",
"0.56350505",
"0.56336206",
"0.56290996",
"0.5619414",
"0.5618531",
"0.56178916",
"0.5601956",
"0.5601956",
"0.5597506",
"0.5571776"
] |
0.0
|
-1
|
Override this internal Logger method to clear line
|
def add(*args)
clear_line
super(*args)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def clear_line\n CLEAR_LINE\n end",
"def clear_line; print \"\\e[2K\" end",
"def clear\n @lines.clear\n end",
"def clear_line\n puts \"\\e[0A\\e[0G\"\n end",
"def clear_line!\n print \"\\r\\e[2K\"\n end",
"def clear_line\n CSI + '2K' + column(1)\n end",
"def clear_line\n print \"\\r%s\\r\" % ' ' * columns\n end",
"def erase_line\n # highline does not expose the output stream\n HighLine.default_instance.instance_variable_get('@output').print \"\\r\\e[K\"\n end",
"def clear_line_before\n CSI + '1K'\n end",
"def clear_line_after\n CSI + '0K'\n end",
"def log_reset\n @log_device.truncate(0) if defined? @log_device\n self\n end",
"def reset_own_logger\n self.logger = nil\n end",
"def delete_logging_statement\n super\n end",
"def clear\n writeln(\"clear\")\n end",
"def _clear_line(lines = 1)\n raise ArgumentError, \"Number of lines to clear (#{lines}) must be > 0\" if lines < 1\n while lines > 0\n STDOUT.write \"\\r\\e[2K\"\n lines -= 1\n STDOUT.write \"\\e[A\" if lines > 0\n end\n end",
"def clear_log\n @messages = []\n end",
"def empty_line\n end",
"def clear_log\n request('clearLog')\n end",
"def clear_log\n @output = []\n end",
"def clear(line, c=\".\")\n\tline.each_index do |i|\n\t\tline[i] = c\n\tend\nend",
"def log_lines\n\n self.each do |line|\n clean_line = line.to_s.chomp.gsub(\"\\\\n\",\"\")\n log.info(x) { line } if clean_line.length > 0\n end\n\n end",
"def clear\n\n # remove the trailing newline, otherwise an upper line will get eaten\n @rendered.sub!(/\\n\\z/, '')\n\n # determine how many lines to move up\n lines = @rendered.scan(/\\n/).length\n\n if @bottomline\n print IOChar.cursor_down + IOChar.carriage_return + IOChar.clear_line + IOChar.cursor_up\n end\n\n # jump back to the first position and clear the line\n print IOChar.cursor_down + IOChar.carriage_return + IOChar.clear_line + IOChar.cursor_up + IOChar.clear_line + IOChar.carriage_return + ( IOChar.cursor_up + IOChar.clear_line ) * lines + IOChar.clear_line\n end",
"def newline\n log('')\n end",
"def newline\n log('')\n end",
"def clear_line_items\n @line_items = []\n end",
"def print_clear; print \"\\e[0J\" end",
"def empty_line\r\n puts \"\\n\"\r\n end",
"def clear!\n begin\n @trigger << \"c\"\n rescue IOError\n end\n end",
"def reset\n @line_no, @last_lexeme = 0, [\"\\n\"]\n super\n end",
"def erase_line_to_beginning\n ConsoleGlitter.escape('1K')\n end",
"def clear_debug_console\n @debugscr.clrtoeol(0...@lines) if Rails.env.development? && @debug\n end",
"def clear\n io.truncate(0)\n io_index.clear\n self\n end",
"def clear; puts \"\\e[2J\" end",
"def clear_log!(name)\n put :clear_log!, {:name => name}\n end",
"def original_line; end",
"def erase_line_to_end\n ConsoleGlitter.escape('0K')\n end",
"def empty!\n @line_items = []\n end",
"def reset_log_data\n self.class.without_logging { update_column(:log_data, nil) }\n end",
"def reset\n @registry = {}\n @logging = false\n @line_item_limit = 1000\n end",
"def reset\n self.level = :normal\n flush\n close_log(@last_file)\n @last_file = nil\n close_log(@job_file)\n @job_file = nil\n @custom_logs.each do |name, log|\n close_log(log)\n end\n @custom_logs = {}\n end",
"def remove_line(line)\n\t\t@lines.delete(line)\n\tend",
"def clear\n synchronize do\n @locks.delete(Logging::Logger.thread_name)\n end\n end",
"def remove_line(line_num)\n\t\tif @line_indices == []\n\t\t\t@text = \"\"\n\t\telse\n\t\t\tlength = line_index(line_num + 1) - line_index(line_num)\n\t\t\t@text[line_index(line_num) + 1 .. line_index(line_num + 1)] = \"\"\n\t\t\t@line_indices.delete_at(line_num)\n\t\t\t(line_num...@line_indices.length).each { |i| @line_indices[i] -= length }\n\t\tend\n\tend",
"def clear\n say \"\\e[2J\\e[H\"\n end",
"def clear\n ''\n end",
"def flush\n @log.flush if @log.respond_to?(:flush)\n end",
"def clear!\n @output = ''\n @verbose = false\n end",
"def line=(_); end",
"def line=(_); end",
"def clear\n $stdout.print \"\\n\"\n $stdout.flush\n end",
"def puts_clear; puts \"\\e[0J\" end",
"def reset_logging\n\t\tRoninShell.reset_logger\n\tend",
"def blank_line\n output \"\"\n end",
"def newline\n log\n end",
"def clear_output\n @out_notes.clear\n self\n end",
"def clear\n @class_formatters.clear\n @module_formatters.clear\n self\n end",
"def reset_log_data\n without_logging { update_all(log_data: nil) }\n end",
"def ti_delete_line\n\ttictl(\"dl\")\n end",
"def clear() end",
"def clear() end",
"def flush\n @logger.flush if @logger.respond_to?(:flush)\n end",
"def clear_eol\n print \"\\e[0K\"\n end",
"def clear_messages\n Facter::Log.clear_messages\n end",
"def _clear_row pad, lineno\n raise \"unused\"\n @color_pair ||= get_color($datacolor, @source.color, @source.bgcolor)\n cp = @color_pair\n att = NORMAL\n @_clearstring ||= \" \" * (@source.width - @left_margin - @int_w)\n # with int_w = 3 we get that one space in popuplist\n # added attr on 2014-05-02 - 00:16 otherwise a list inside a white bg messagebox shows\n # empty rows in black bg.\n FFI::NCurses.wattron(pad,FFI::NCurses.COLOR_PAIR(cp) | att)\n FFI::NCurses.mvwaddstr(pad,lineno, @left_margin, @_clearstring) \n FFI::NCurses.wattroff(pad,FFI::NCurses.COLOR_PAIR(cp) | att)\n end",
"def flush\n return unless @buffer.size > 0\n @log.write(@buffer.slice!(0..-1).join)\n end",
"def flush\n return unless @buffer.size > 0\n @log.write_method(@buffer.slice!(0..-1).join)\n end",
"def handle_interrupt\n if @buffer\n @buffer.pop; @buffer_info.pop; history.pop\n if @buffer.empty?\n @buffer = @buffer_info = nil\n print '[buffer empty]'\n return super\n else\n puts \"[previous line removed|#{@buffer.size}]\"\n throw :multiline\n end\n else\n super\n end\n end",
"def clear\n end",
"def clear_progress\n return unless show_progress\n print_no_newline(\"\\e[?25h\\e[2K\")\n @progress_msg = nil\n end",
"def flush\n return if @current_line.nil?\n\n @stream << @current_line\n @current_line = nil\n end",
"def reset_logger!\n Thread.current[:merb_logger] = nil\n end",
"def clear\n return\n end",
"def clear\n trace.elegibility.transform_values { |_| 0 }\n trace.extended.each_value do |ext|\n ext.transform_values { |_| 0 }\n end\n\n error.responsibility = error.projected = error.gated = 0\n end",
"def clear\n # self\n end",
"def clear!; end",
"def clear!; end",
"def clear!; end",
"def clear; end",
"def clear; end",
"def clear; end",
"def clear; end",
"def clear; end",
"def clear; end",
"def clear; end",
"def delete_all_lines\n @deleted_lines.concat @lines\n @lines.clear\n end",
"def receive_line line\n super(line)\n write_output\n end",
"def fresh_line?; end",
"def clear\n self.color = COLOR_CLEAR unless self.color == COLOR_CLEAR\n end",
"def setRemoveEmptyLines(value)\n @fields['remove_empty_lines'] = value\n self\n end",
"def clear\n # clear the lineage\n @lineage.clear\n # if the visited hash is not shared, then clear it\n @visited.clear unless @options.has_key?(:visited)\n end",
"def clear\n raise \"not implemented\"\n end",
"def delete_at(line_number)\n self[line_number].delete\n super(line_number)\n update_line_numbers!\n end",
"def clear\n self.failure_occurred = false\n self.message = nil\n self.time = Float::NAN\n end",
"def clear\n\t\trequest = Packet.create_request('stdapi_sys_eventlog_clear')\n\n\t\trequest.add_tlv(TLV_TYPE_EVENT_HANDLE, self.handle);\n\n\t\tresponse = client.send_request(request)\n\t\treturn self\n\tend",
"def clear\n do_clear\n end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end",
"def line; end"
] |
[
"0.76990247",
"0.71693414",
"0.701906",
"0.69899535",
"0.68916905",
"0.68834376",
"0.6804096",
"0.67651963",
"0.6668352",
"0.66344136",
"0.661538",
"0.64576143",
"0.6420297",
"0.63490784",
"0.6344306",
"0.6299547",
"0.628575",
"0.6260652",
"0.62599903",
"0.6233663",
"0.6181133",
"0.615999",
"0.6103466",
"0.6103466",
"0.6100643",
"0.60718924",
"0.6032476",
"0.60195774",
"0.6018798",
"0.60170174",
"0.601635",
"0.5996603",
"0.5988289",
"0.59593976",
"0.5910681",
"0.59094256",
"0.5863308",
"0.5862041",
"0.58584493",
"0.585736",
"0.585652",
"0.58552265",
"0.5855104",
"0.58535814",
"0.5839234",
"0.5826064",
"0.58101493",
"0.5797491",
"0.5797491",
"0.5783794",
"0.5766351",
"0.57625884",
"0.57612276",
"0.5757405",
"0.5754041",
"0.57377404",
"0.57345194",
"0.5729391",
"0.57291144",
"0.57291144",
"0.57231915",
"0.5699468",
"0.5669829",
"0.56622314",
"0.56618017",
"0.5653913",
"0.5644308",
"0.56324273",
"0.56318575",
"0.56243515",
"0.56120044",
"0.560822",
"0.56029725",
"0.5602166",
"0.5601014",
"0.5601014",
"0.5601014",
"0.55915457",
"0.55915457",
"0.55915457",
"0.55915457",
"0.55915457",
"0.55915457",
"0.55915457",
"0.5590722",
"0.55840486",
"0.5573367",
"0.5572371",
"0.5571841",
"0.5569377",
"0.5564684",
"0.5564118",
"0.5555843",
"0.55496347",
"0.55421203",
"0.55355954",
"0.55355954",
"0.55355954",
"0.55355954",
"0.55355954",
"0.55355954"
] |
0.0
|
-1
|
Log format (from Logger implementation). Used by Logger internally
|
def format_log(sev, _time, _prog, msg)
"[#{sev.downcase}]: #{msg}\n"
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def log_formatter; end",
"def log_formatter; end",
"def log_format\n if configuration.log_format.nil? || configuration.log_format.empty?\n format = '%{KIND}: %{message} on line %{line}'\n format.prepend('%{path} - ') if configuration.with_filename\n format.concat(' (check: %{check})')\n configuration.log_format = format\n end\n\n configuration.log_format\n end",
"def format_log(sev, _time, _prog, msg); end",
"def log_formatter=(_arg0); end",
"def log_formatter=(_arg0); end",
"def format_log(msg)\n msg = colorize_log(msg)\n msg = remove_prefix(msg)\n \"#{msg}\\n\"\n end",
"def to_log_format\n @log_format ||= begin\n attributes = []\n attributes << \"#{LOG_ATTR_ENV}=#{env}\" unless env.nil?\n attributes << \"#{LOG_ATTR_SERVICE}=#{service}\"\n attributes << \"#{LOG_ATTR_VERSION}=#{version}\" unless version.nil?\n attributes << \"#{LOG_ATTR_TRACE_ID}=#{trace_id}\"\n attributes << \"#{LOG_ATTR_SPAN_ID}=#{span_id}\"\n attributes << \"#{LOG_ATTR_SOURCE}=#{Core::Logging::Ext::DD_SOURCE}\"\n attributes.join(' ')\n end\n end",
"def datetime_format\n @logger.first.datetime_format\n end",
"def log(s, type = :info)\n\t\tcolor = :gray\n\t\tcase type\n\t\twhen :error\n\t\t\tcolor = :red\n\t\twhen :warning\n\t\t\tcolor = :yellow\n\t\twhen :debug\n\t\t\tcolor = :purple\n\t\tend\n\t\tsuper _fmt(color, s), type\n\tend",
"def log_fmt(msg)\n \"[connection:#{connection.identifier}] [channel:#{self.class.id}] #{msg}\"\n end",
"def textLogFormat _args\n \"textLogFormat _args;\" \n end",
"def format(log_record)\n msg_txt = self.formatMessage(log_record)\n msg_txt = msg_proc.call(log_record, msg_txt) if msg_proc\n return unless msg_txt\n\n lvl = @level_labels[log_record.level]\n indent = @indent || 0\n spacer = ''\n wrap_width = @width - indent\n if log_record.level.intValue < JavaUtilLogger::Level::INFO.intValue\n spacer = ' '\n wrap_width -= 2\n end\n msg = wrap_width > 0 ? Console.wrap_text(msg_txt, wrap_width) : [msg_txt]\n sb = java.lang.StringBuilder.new()\n msg.each_with_index do |line, i|\n if i == 0\n fmt = java.lang.String.format(@format_string,\n log_record.millis,\n log_record.logger_name,\n log_record.logger_name,\n lvl,\n msg[i],\n log_record.thrown,\n spacer)\n else\n fmt = java.lang.String.format(@format_string,\n log_record.millis, '', '', '', msg[i], nil, spacer)\n end\n sb.append(fmt)\n sb.append(LINE_END) if @width < 0 || fmt.length < @width\n end\n sb.toString()\n end",
"def log\n out.sync = true\n @log ||= Logger.new(out)\n\n @log.formatter = proc do |severity, datetime, progname, msg|\n if verbose\n string = \"#{severity} [#{datetime.strftime('%Y-%m-%d %H:%M:%S.%2N')}]: \"\n else\n string = \"[#{datetime.strftime('%H:%M:%S')}]: \"\n end\n\n string += \"#{msg}\\n\"\n\n string\n end\n @log\n end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def format; end",
"def colorize_logging; end",
"def formatter \n original_formatter = Logger::Formatter.new\n Proc.new do |severity, datetime, progname, msg|\n original_formatter.call(severity, datetime, \n \"#{progname}##{caller_method}\",\n msg.dump)\n end\n end",
"def format_log_message(msg)\n \"[Cloudtasker/Server][#{id}] #{msg}\"\n end",
"def format!(logger)\n logger.formatter = proc { |severity, datetime, progname, msg| \"#{msg}\" }\n end",
"def format(format, *arguments); end",
"def format_message(severity, timestamp, progname, msg)\n \"#{AUTHORIZATION_SYSTEM_LOG_MSG_PREFIX} #{timestamp.to_formatted_s(:db)} #{severity} #{msg}\\n\" \n end",
"def format(fmt, *rest) end",
"def log string, importance = 0, component = nil\n time_string = \"(\" + Time.now.strftime(DATEFORMAT) + \")\"\n\n LOGGERS.each { |logger|\n logger.log_raw(string.to_s, component.to_s, time_string) if logger.should_show(component, importance)\n }\nend",
"def set_loggers_format\n [@logger, @logger_stderr].each do |logger|\n logger.formatter = proc do |severity, _datetime, progname, msg|\n # If the message already has control characters, don't colorize it\n keep_original_color = msg.include? \"\\u001b\"\n message = \"[#{Time.now.utc.strftime('%F %T')} (PID #{$PROCESS_ID} / TID #{Thread.current.object_id})] #{severity.rjust(5)} - [ #{progname} ] - \"\n message << \"#{msg}\\n\" unless keep_original_color\n LEVELS_MODIFIERS[severity.downcase.to_sym].each do |modifier|\n message = message.send(modifier)\n end\n message << \"#{msg}\\n\" if keep_original_color\n message\n end\n end\n end",
"def formatter; end",
"def formatter; end",
"def formatter; end",
"def datetime_format\n @loggers.each do |logger|\n return logger.datetime_format if logger.respond_to?(:datetime_format)\n end\n end",
"def format(level, context, message)\n msg = message.evaluated_message\n\n case msg\n when Hash\n # Assume caller is following conventions\n log = msg.dup\n else\n # Otherwise treat as String\n log = { :message => msg.to_s.strip }\n end\n\n log[:timestamp] = timestamp\n log[:level] = format_level(level)\n log[:pid] = Process.pid\n\n unless Thread.current == Thread.main\n log[:thread] = Thread.current.object_id\n end\n\n log[:context] = context\n\n if message.ndc.any?\n log[:ndc] = message.ndc.to_a\n end\n\n if message.error\n error = message.error\n\n log[:error_class] = error.class.to_s\n log[:error_message] = error.message\n log[:error_backtrace]\n\n if error.respond_to?(:backtrace)\n backtrace = error.backtrace\n backtrace = backtrace.take(backtrace_limit) if backtrace_limit\n log[:error_backtrace] = backtrace.join(\"\\n\")\n end\n end\n\n JSON.generate(log.to_h)\n end",
"def format_log_message file, lineno, line, parameters\n message = insert_parameters(line, parameters)\n return \"#{file[:file_name]}@#{lineno}: #{message}\"\nend",
"def format\n @_format\n end",
"def format_log_entry(message, dump = nil)\n if Rails.application.config.colorize_logging\n if @@row_even\n @@row_even = false\n message_color, dump_color = \"4;36;1\", \"0;1\"\n else\n @@row_even = true\n message_color, dump_color = \"4;35;1\", \"0\"\n end\n\n log_entry = \" \\e[#{message_color}m#{message}\\e[0m \"\n log_entry << \"\\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\\e[0m\" % dump if dump\n log_entry\n else\n \"%s %s\" % [message, dump]\n end\n end",
"def default_format(f)\n @default_formatter = Log4r::PatternFormatter.new(:pattern => f)\n\n #\n # Set all current outputters\n #\n result.outputters.each do |o|\n o.formatter = @default_formatter if o.formatter.is_a?(Log4r::DefaultFormatter)\n end\n\n @default_formatter\n end",
"def configure_logging(logger)\n logger.level = LOG_LEVEL\n logger.datetime_format = '%Y-%m-%d %H:%M:%S'\n logger.formatter = proc do |severity, datetime, progname, msg|\n color = case severity\n when \"DEBUG\" then :light_white\n when \"INFO\" then :light_yellow\n when \"WARN\" then :light_red\n when \"ERROR\" then :blue\n when \"FATAL\" then :magenta\n when \"UNKNOWN\" then :cyan\n end\n \"#{datetime}: #{msg.colorize(color)}\\n\"\n end\n logger\nend",
"def format!; end",
"def format_message level, time, msg\n prefix = case level\n when \"warn\"; \"WARNING: \"\n when \"error\"; \"ERROR: \"\n else \"\"\n end\n \"[#{time.to_s}] #{prefix}#{msg.rstrip}\\n\"\n end",
"def formatter=(_arg0); end",
"def formatter=(_arg0); end",
"def formatter=(_arg0); end",
"def format_log(raw)\n return \"...\" unless raw\n raw.split(\"\\n\").map do |l|\n # clean stuff we don't need\n l.gsub!(/I\\s+|\\(\\w*\\)|within bounds/, \"\") # gsub(/\\(\\w*\\)/, \"\"\")\n # if ok, span is green\n ok = l =~ /\\[ok\\]/\n if l =~ /\\[\\w*\\]/\n # get some data we want...\n l.gsub(/\\[\\S*\\s(\\S*)\\]\\W+INFO: (\\w*-?\\w*|.*)?\\s\\[(\\w*)?\\]/, \"<span class='gray'>\\\\1</span> | <span class='#{ok ? 'green' : 'red'}'>\\\\3</span> |\").\n # take only the integer from cpu\n gsub(/cpu/, \"cpu %\").gsub(/(\\d{1,3})\\.\\d*%/, \"\\\\1\").\n # show mem usage in mb\n gsub(/memory/, \"mem mb\").gsub(/(\\d*kb)/) { ($1.to_i / 1000).to_s }\n else\n l.gsub(/\\[\\S*\\s(\\S*)\\]\\W+INFO: \\w*\\s(\\w*)/, \"<span class='gray'>\\\\1</span> | <span class='act'>act</span> | \\\\2\")\n end\n\n end.reverse.join(\"</br>\")\n end",
"def log(message)\n puts Time.now.strftime('[%d-%b-%Y %H:%M:%S] ') + message\n end",
"def datetime_format=(datetime_format)\n @loggers.each do |logger|\n logger.datetime_format = datetime_format\n end\n end",
"def __format(params)\n # Define singleton method.\n instance_eval(_format_method, __FILE__, __LINE__)\n # Delegate to singleton method.\n __format(params)\n end",
"def format(fmt)\n @fmt = fmt\n end",
"def log(str)\n puts \"#{Time.now.strftime(\"%Y/%m/%d %H:%M:%S\")}> #{str}\"\n end",
"def log(level, msg)\n puts \"#{level}, #{@org} Customization: #{msg}\"\n end",
"def format\n raise '#format must be implemented in child class'\n end",
"def initialize(format = DEFAULT_FORMAT, width = nil)\n super()\n @format_string = format\n @width = width || Console.width || -1\n mark = java.lang.String.format(@format_string, Time.now,\n '', '', '', '!$!', nil, nil)\n @indent = mark.lines.first.index('!$!')\n @level_labels = Hash.new{ |h, k| h[k] = k }\n @level_labels[JavaUtilLogger::Level::WARNING] = 'WARN'\n @level_labels[JavaUtilLogger::Level::SEVERE] = 'ERROR'\n @level_labels[JavaUtilLogger::Level::FINEST] = 'DEBUG'\n end",
"def default_formatter\n if protocol == :syslog\n # Format is text output without the time\n SemanticLogger::Formatters::Default.new(time_format: nil)\n else\n SemanticLogger::Formatters::Syslog.new(facility: facility, level_map: level_map, max_size: max_size)\n end\n end",
"def log(*args)\n logf('%s', *args)\n end",
"def formatter fmt\n @formatter = fmt\n end",
"def log(message); logger.info(message); end",
"def format_message(severity, timestamp, progname, msg)\n # $stderr.puts \"format_message: #{msg}\"\n sprintf \"%s,%03d %7s: %s%s\\n\",\n timestamp.strftime(\"%Y-%m-%d %H:%M:%S\"),\n (timestamp.usec / 1000).to_s,\n severity,\n prefix.nil? ? \"\" : \"#{prefix} \",\n msg\n end",
"def log_writer; end",
"def colorize_logging=(_arg0); end",
"def formatter\n Proc.new{|severity, time,progname, msg|\n formatted_time = time.strftime(\"%Y-%m-%d,%H:%M:%S\")\n \"#{formatted_time},#{msg.to_s.strip}\\n\"\n }\n end",
"def format_message(message)\n format = log_format\n puts format % message\n\n puts \" #{message[:reason]}\" if message[:kind] == :ignored && !message[:reason].nil?\n end",
"def yellow_log_formatter()\n orig_formatter = ::Logger::Formatter.new\n\n proc do |s,dt,pn,msg|\n \"#{CLEAR}#{YELLOW}#{orig_formatter.call(s,dt,pn,msg)}#{CLEAR}\"\n end\n end",
"def datetime_format=(datetime_format)\n @loggers.each do |logger|\n logger.datetime_format = datetime_format if logger.respond_to?(:datetime_format=)\n end\n end",
"def log (msg, **kwargs) Log.write(msg, :info, kwargs) end",
"def log_interpolate prefix, text, time = timestamp\n message = class_trait[:format].dup\n\n vars = { '%time' => time, '%prefix' => prefix, '%text' => text }\n vars.each{|from, to| message.gsub!(from, to) }\n\n message\n end",
"def log(str); puts \"[#{Time.now}] #{str}\"; end",
"def set_format *args\n global, format = args.fetch_opts [nil], :type => :console, :time => [\"%H:%M:%S\", \"%03d\"] \n format = if format[:type] == :html; {\n :caller => \"<a class='l'>%f:%l</a> <a class='m'>:%m</a>\", \n :format => \"<div class='line'><a class='t'>%time</a> <a class='%mode'>%mode</m> [%caller]: <p>%text</p>%att</div>\",\n :att =>\"<div class='att'><div class='hide'>+</div><pre>%s</pre></div>\",\n :serializer => RMTools::RMLogger::HTML\n }; else {\n :caller => \"#{@c.gray('%f:%l')} #{@c.red_bold(':%m')}\", \n :format => \"%time %mode [%caller]: %text\"\n } end.merge format\n if global\n _set_format @default_format, format\n else\n _set_format(file_format={}, format)\n @file_formats[File.expand_path(caller[0].till ':')] = file_format\n end\n end",
"def set_up_logger( file )\n # $stdout = File.new( file, \"w\" )\n logger = Logger.new( file )\n \n logger.datetime_format = \"%H:%M:%S.%L\" # HH:MM:SS\n logger.formatter = Proc.new{ |severity,datetime,prog,msg|\n str = \"#{datetime} #{severity}: #{msg}\\n\"\n str\n }\n \n logger\nend",
"def format_msg(hash, level)\n @level = level # Log level\n str = \"\" # Final String we return. We keep appending to this\n count = 0 # Use to indent on 2nd+ iteration\n\n str_keys_values = add_key_values_to_str(hash)\n s_msg = split_msg(str_keys_values) # Split message incase it's MAX_CHAR+ chars\n\n s_msg.each do |n|\n str += count == 0 ? \"#{add_log_level(str)}#{get_date} | \" : \"#{add_log_level(str)}\"\n str += count == 0 ? \"#{n}\\n\" : \" \" * (get_date.length) + \" | #{n}\\n\" # Indent if 2nd+ iteration\n count += 1\n end\n\n str\n end",
"def formats; end",
"def formats; end",
"def format(level, context, message)\n msg = message.to_s.strip\n thread = thread_context ? \"[#{thread_name}] - \" : nil\n\n if message.ndc.any?\n msg = \"#{thread}#{level.to_s.upcase} - #{context} #{message.ndc.join(' ')} - #{msg}\"\n else\n msg = \"#{thread}#{level.to_s.upcase} - #{context} - #{msg}\"\n end\n\n with_backtrace(message, msg)\n end",
"def log(format: nil)\n format_pattern =\n case format\n when :author\n '%aN'\n when :message\n '%B'\n end\n\n cmd = %w[log --topo-order]\n cmd << \"--format='#{format_pattern}'\" if format_pattern\n\n output, = run_git(cmd)\n output&.squeeze!(\"\\n\") if format_pattern == :message\n\n output\n end",
"def [](name)\n ProcessLog.instance_variable_get(:@format)[name]\n end",
"def logger_output; end",
"def _process_format(format); end",
"def _process_format(format); end",
"def format_message\n return @format_message if @format_message\n\n @format_message = self.message.dup\n\n if self.line\n @format_message << \" near line #{self.line}\"\n end\n\n if self.code\n @format_message << \": #{format_code}\"\n end\n\n @format_message\n end",
"def loggable\n \"%-15s\\t%7d\\t%7.2f\\t%-23s\" % [tube, priority.to_i, delay.to_f, key]\n end",
"def format\n @format\n end",
"def format=(_arg0); end",
"def format=(_arg0); end",
"def format=(_arg0); end",
"def format=(_arg0); end",
"def loggable\n \"%-15s\\t%7d\\t%7.2f\\t%-23s\" % [tube, priority, delay, key]\n end",
"def log(str, log_type = :info)\n str = \"- ERROR - #{str}\" if log_type == :error\n puts str\nend",
"def format(arg)\n str = if arg.is_a?(Exception)\n \"#{arg.class}: #{arg.message}\\n\\t\" <<\n arg.backtrace.join(\"\\n\\t\") << \"\\n\"\n elsif arg.respond_to?(:to_str)\n arg.to_str\n else\n arg.inspect\n end\nend",
"def render_log(template, values)\n template && values ? format(template, values) : template\n end",
"def format\n raise NotImplementedError\n end",
"def log_level; end",
"def log_level; end",
"def log s\n # Open log, if necessary\n if config[:log]\n puts \"LOG: #{s}\" if config[:debug]\n File.open(config[:logfile], 'a') do |f|\n f.puts \"#{Time.now.strftime(config[:time_format])} #{s}\"\n end\n end\n end",
"def format_message(msg)\n \"#{@method_name} #{msg}\"\n end",
"def logger\n ::Logger.new($stdout).tap do |log|\n log.formatter = proc do |severity, _datetime, _progname, msg|\n prep = ' ' * (severity.size + 3)\n message = msg.lines.map.with_index do |str, i|\n next str if i.zero?\n\n str.strip.empty? ? str : prep + str\n end\n color = severity.downcase.to_sym\n msg = +\"[#{SeccompTools::Util.colorize(severity, t: color)}] #{message.join}\"\n msg << \"\\n\" unless msg.end_with?(\"\\n\")\n msg\n end\n end\n end",
"def configure_logger_for(classname)\n # handle case in which log path does not exists\n begin\n logger = Logger.new(@log_path)\n rescue Errno::ENOENT\n FileUtils.mkdir_p File.dirname @log_path\n retry\n end\n\n logger.progname = classname\n logger.level = @level\n logger.formatter = proc { |severity, datetime, progname, msg|\n case severity\n when 'DEBUG'\n spaciator = \" *\"\n after_space = \"\"\n when 'INFO'\n spaciator = \" **\"\n after_space = \" \"\n when 'WARN'\n spaciator = \" ***\"\n after_space = \" \"\n when 'ERROR'\n spaciator = \" ****\"\n after_space = \"\"\n when 'FATAL'\n spaciator = \"*****\"\n after_space = \"\"\n else\n spaciator = \" \"\n after_space = \"\"\n end\n\n formatted_output = \" #{spaciator} [#{severity}]#{after_space} [#{datetime}] -- #{msg} { #{progname} }\\n\"\n formatted_output\n }\n logger\n end",
"def log(severity, message, tid)\n now = Time.now\n ss = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'][severity]\n ss = '' if ss.nil?\n if @formatter.nil?\n msg = \"#{ss[0]}, [#{now.strftime('%Y-%m-%dT%H:%M:%S.%6N')} ##{tid}] #{ss} -- : #{message}\\n\"\n else\n msg = @formatter.call(ss, now, tid, message)\n end\n @logger.add(severity, msg)\n @forward.log(severity, message, tid) unless @forward.nil?\n end",
"def log(log)\n post(formatter.call(log, self), log.time.strftime(@logging_path))\n end"
] |
[
"0.7837322",
"0.7837322",
"0.76155096",
"0.7320731",
"0.728268",
"0.728268",
"0.70351446",
"0.6886894",
"0.68730956",
"0.685765",
"0.680251",
"0.66508776",
"0.66429925",
"0.65977913",
"0.65487",
"0.65487",
"0.65487",
"0.65487",
"0.65487",
"0.65487",
"0.65487",
"0.65487",
"0.6501186",
"0.6499931",
"0.64923817",
"0.64764404",
"0.6456485",
"0.6423302",
"0.6419524",
"0.6354267",
"0.6349907",
"0.6349614",
"0.6349614",
"0.6349614",
"0.63438064",
"0.6315102",
"0.6290171",
"0.6286343",
"0.6283954",
"0.6274474",
"0.6219339",
"0.6188611",
"0.617525",
"0.61413115",
"0.61413115",
"0.61413115",
"0.6135811",
"0.6122027",
"0.61119854",
"0.6099066",
"0.60783494",
"0.60641",
"0.6058667",
"0.60499096",
"0.60470927",
"0.60457313",
"0.60301083",
"0.6028008",
"0.6025856",
"0.602014",
"0.6013054",
"0.6009438",
"0.6007033",
"0.60036385",
"0.5981654",
"0.5974893",
"0.59737444",
"0.59718776",
"0.5951664",
"0.59425265",
"0.5936973",
"0.5909225",
"0.59077877",
"0.59077877",
"0.5903232",
"0.58978856",
"0.58942163",
"0.5861966",
"0.5860179",
"0.5860179",
"0.5850268",
"0.5840216",
"0.5834232",
"0.5827904",
"0.5827904",
"0.5827904",
"0.5827904",
"0.58263385",
"0.58037007",
"0.5802977",
"0.58020735",
"0.57963353",
"0.5777388",
"0.5777388",
"0.5775725",
"0.57699186",
"0.5732067",
"0.5729905",
"0.5729773",
"0.5719367"
] |
0.6956505
|
7
|
Subject can be set in your I18n file at config/locales/en.yml with the following lookup: en.voicemail.new_voicemail.subject
|
def new_voicemail_email(call)
@user = call.user
@call = call
@recording = call.recording
mail to: @user.email, subject: "Voicemail message from #{@call.caller_number}"
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def message_subject=(value)\n @message_subject = value\n end",
"def subject=(string)\n set('Subject', string)\n end",
"def set_EmailSubject(value)\n set_input(\"EmailSubject\", value)\n end",
"def set_EmailSubject(value)\n set_input(\"EmailSubject\", value)\n end",
"def set_EmailSubject(value)\n set_input(\"EmailSubject\", value)\n end",
"def set_EmailSubject(value)\n set_input(\"EmailSubject\", value)\n end",
"def subject\n @subject ||= Envelope::MessageTools.normalize(message.subject || '')\n end",
"def subject\n self['subject'] || msg['subject']\n end",
"def subject=(subject); @message_impl.setSubject subject; end",
"def subject_for(template, attributes = {})\n subject = EmailTemplate.subject_for(template)\n subject = I18n.t(\"email_templates.#{template}.default_subject\") if subject.nil?\n subject = \"No Subject\" if subject.nil?\n Florrick.convert(subject, add_default_attributes(attributes))\n end",
"def subject_name=(value)\n @subject_name = value\n end",
"def subject (recipient)\n subject_variables = alert_variables[:subject].dup\n subject_variables.merge!(recipient_details(recipient))\n subject = \"#{I18n.t(\"#{recipient_type.to_s}_subject_#{alert_name.to_s}\", subject_variables)}\"\n subject\n end",
"def formatted_subject(text)\n name = PersonMailer.global_prefs.app_name\n label = name.blank? ? \"\" : \"[#{name}] \"\n \"#{label}#{text}\"\n end",
"def setSubject(subject)\n @fields['subject'] = subject\n self\n end",
"def setSubject(subject)\n @fields['subject'] = subject\n self\n end",
"def setSubject(subject)\n @fields['subject'] = subject\n self\n end",
"def setSubject(subject)\n @fields['subject'] = subject\n self\n end",
"def subject\n @mail.subject\n end",
"def subject() self.headers[\"Subject\"] || \"[NO SUBJECT]\" end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def set_Subject(value)\n set_input(\"Subject\", value)\n end",
"def subject\n @subject ||= \"(sans sujet)\"\n if @no_header_subject.nil?\n \"#{header_subject}#{@subject}\"\n else\n @subject\n end\n end",
"def subject\n @options.fetch(:subject) { \"Invitation\" }\n end",
"def email_subject(form)\n \"#{form.type_of_enquiry} - #{reference}\"\n end",
"def subject=(value)\n @subject = value\n end",
"def subject=(value)\n @subject = value\n end",
"def subject=(value)\n @subject = value\n end",
"def subject=(value)\n @subject = value\n end",
"def subject=(value)\n @subject = value\n end",
"def subject=(value)\n @subject = value\n end",
"def subject_name\n subject_full_name\n end",
"def set_subject(subject)\n\t\tend",
"def SetSubject(subject)\n\t\t#Subject of document\n\t\t@subject = subject\n\tend",
"def subject\n title \n end",
"def get_email_subject(email_type)\n email_subject = email_type\n case(email_type)\n when \"welcome\"\n email_subject = \"Welcome to Aspera Files\"\n when \"reset\"\n email_subject = \"Password Reset\"\n end\n return email_subject\n end",
"def subject_name\n return @subject_name\n end",
"def subject(options = {})\n options = { :capitalize => true, :case => Grammar::Case::SUBJECT }.merge(options)\n pronoun_or_noun(@subject, @audience, options)\n end",
"def translate(mapping, key)\n I18n.t(:\"#{mapping.name}_subject\", :scope => [:devise, :mailer, key],\n :default => [:subject, key.to_s.humanize])\n end",
"def subject\n self['subject']\n end",
"def compose_email\n @title = t 'conclusion_draft_review.send_by_email'\n end",
"def subject\n @subject=EzCrypto::Name.new(@cert.subject) unless @subject\n @subject\n end",
"def email_subject\n sponsor_name = @config.plan.sponsor_name\n display_date = @date.to_s()\n if @config.div_id.present?\n email_subject = \"Payroll report for #{sponsor_name} for division #{@config.division_name}: #{display_date}\"\n else\n email_subject = \"Payroll report for #{sponsor_name}: #{display_date}\"\n end\n return email_subject\n end",
"def subject\n message.subject\n end",
"def email_subject(&blk)\n @email_subject_block = blk if blk\n @email_subject_block\n end",
"def set_title\n @title = t(:message_2, :scope => [:controller, :exams])\n end",
"def normalize_subject_name\n self.subject = subject.downcase.titleize\n end",
"def translate(mapping, key)\n I18n.t(:\"notifications_subject\", :scope => [:eventifier, :notifications, key],\n :default => [:subject, key.to_s.humanize])\n end",
"def subject_titles\n @subject_titles ||= sw_subject_titles\n end",
"def subject; @message_impl.getSubject; end",
"def deliver_invitation(options = {})\n super(options.merge(subject: _('A Data Management Plan in %{application_name} has been shared with you') % {application_name: Rails.configuration.branding[:application][:name]}))\n end",
"def set_subject\n url = Settings.hqva_mobile.url\n icn = user.icn\n appointment_id = data[:appointment_id]\n\n {\n use: SUBJECT_USE,\n value: \"#{url}/appointments/v1/patients/#{icn}/Appointment/#{appointment_id}\"\n }\n end",
"def get_subject_name\n subject_name = subject_header.text.sub! 'Subject:', ''\n subject_name = subject_name.strip!\n subject_name\n end",
"def get_subject\n\t\tend",
"def mmm_test_subj_call\n ->(candidate) { I18n.t('email.test_monthly_mail_subject_initial_input', candidate_account_name: candidate.account_name) }\n end",
"def message_subject\n return @message_subject\n end",
"def subject(*extra)\n subject = \"\"\n subject << \"#{@project.name} | \" if @project\n subject << extra.join(' | ') if extra.present?\n subject\n end",
"def choose_subject(action, params = {})\n scope = [:mailers, mailer_name, action]\n key = :subject\n experiment_name = \"#{mailer_name}_mailer_#{action}_subject\".to_sym\n if experiment_active?(experiment_name)\n scope << key\n key = ab_test(experiment_name)\n end\n params.merge!(scope: scope)\n I18n.t(key, params)\n end",
"def set_subject_and_message(form, subject, message)\n raise Impostor::MissingTemplateMethodError.new(\"set_subject_and_message must be implemented\")\n end",
"def set_subject\n @subject = Subject.friendly.find(params[:id])\n end",
"def invite_subject\n \"Your invitation to #{org_name.possessive} Creative Difference Dashboard\"\n end",
"def subject=(text)\n current_div.text_field(:id=>\"comp-subject\").set text\n end",
"def data_subject=(value)\n @data_subject = value\n end",
"def set_subject\n @subject = Subject.find(params[:subject_id])\n end",
"def set_subject\n\t\t\t@subject = Subject.find(params[:id])\n\t\tend",
"def subject=(subject)\n self.subjects = [subject]\n end",
"def newcompany_email(company)\n @company = company\n @message = t('mailers.company.created')\n \n emails = AdminUser.all.collect(&:email).join(\",\")\n\n mail(:to => emails, :subject => \"#{t('site_title')}: #{@message}\")\n \n end",
"def subject_alternative_name\n extensions[R509::Cert::Extensions::SubjectAlternativeName]\n end",
"def course_notification_item_details(course)\n t('notifications.subscribe_course')\n end",
"def create_subject(options = {})\n default_values = { :name => 'Test subject' }\n Subject.create(default_values.merge(options))\n end",
"def set_project_subject\n @project_subject = ProjectSubject.find(params[:id])\n end",
"def adhoc_test_subj_call\n ->(candidate) { I18n.t('email.test_adhoc_subject_initial_input', candidate_account_name: candidate.account_name) }\n end",
"def set_subject\n @subject = Subject.find params[:subject_id]\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def set_title\n @title = t(:message_0, :scope => [:controller, :scholarships])\n end",
"def set_subject\n @subject = Subject.find(params[:id])\n end",
"def custom_mail( user, subject, title, contents )\n @user = user\n @host = GogglesCore::AppConstants::WEB_MAIN_DOMAIN_NAME\n @contents = contents\n @title = title\n #subject: \"[#{ GogglesCore::AppConstants::WEB_APP_NAME }@#{ @host }] #{ subject }\",\n mail(\n subject: \"#{ subject } [#{GogglesCore::AppConstants::WEB_APP_NAME}]\",\n to: user.email,\n date: Time.now\n )\n end",
"def getEmailDefaults(subject, toEmail, ccEmail = nil)\n if Rails.env.eql? 'development'\n subject = \"[BASL-DEV] #{subject}\"\n toEmail = 'paigepon@gmail.com'\n ccEmail = toEmail\n else\n subject = \"[BASL] #{subject}\"\n end\n mailInfo = {\n :to => toEmail,\n :subject => subject,\n :cc => ccEmail\n }\n mailInfo\n end",
"def set_subject\n @subject = params[:id] ? Subject.find(params[:id]) : Subject.new(subject_params)\n end",
"def set_subject\n @subject = params[:id] ? Subject.find(params[:id]) : Subject.new(subject_params)\n end",
"def subject(*extra)\n subject = \"GitLab\"\n subject << (@project ? \" | #{@project.name_with_namespace}\" : \"\")\n subject << \" | \" + extra.join(' | ') if extra.present?\n subject\n end",
"def i18n_label\n \"email.#{name}_label\"\n end"
] |
[
"0.71846175",
"0.71302485",
"0.7091707",
"0.70904136",
"0.7049268",
"0.7047499",
"0.7041125",
"0.69457525",
"0.69068485",
"0.68505824",
"0.6829657",
"0.6810427",
"0.67638105",
"0.6753094",
"0.6753094",
"0.6753094",
"0.6753094",
"0.6749162",
"0.6747826",
"0.67249143",
"0.67249143",
"0.67249143",
"0.67249143",
"0.67249143",
"0.67249143",
"0.67249143",
"0.67249143",
"0.6661953",
"0.6604425",
"0.65610874",
"0.6526312",
"0.6526312",
"0.6526312",
"0.6526312",
"0.6526312",
"0.6526312",
"0.64902896",
"0.6480627",
"0.6430195",
"0.64119315",
"0.6382034",
"0.63652253",
"0.6364158",
"0.6333784",
"0.63278043",
"0.63098407",
"0.63033193",
"0.6298874",
"0.62833637",
"0.6187384",
"0.617605",
"0.6148436",
"0.6128174",
"0.61051357",
"0.6094183",
"0.60899395",
"0.60736877",
"0.60612744",
"0.6046868",
"0.60177964",
"0.6014379",
"0.5933914",
"0.59324574",
"0.5916618",
"0.58934927",
"0.5888138",
"0.5847321",
"0.58241546",
"0.5823476",
"0.5813931",
"0.5813922",
"0.5803325",
"0.5800483",
"0.57941884",
"0.5778614",
"0.57784534",
"0.5775403",
"0.5762818",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.5753513",
"0.57440454",
"0.57158035",
"0.5709363",
"0.5709363",
"0.56960183",
"0.56960183",
"0.56858194",
"0.5685586"
] |
0.0
|
-1
|
Initializes and returns an Iterator
|
def iter
@iter ||= Iterator.new(self)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_iterator\n\t\tend",
"def begin_iterator\n ListIterator.new @head, self\n end",
"def to_iter\n Iterator.new @entries, @capacity\n end",
"def iterator()\n raise NotImplementedError\n end",
"def getIterator() \n XMLDB::Base::ResourceIterator.getInstance(@obj.getIterator())\n end",
"def iterator\n HashTableIterator.new(@table)\n end",
"def iterator\n return @iterator if @iterator\n\n ElementList.new([self])\n end",
"def initialize(enumerator)\n @enumerator = enumerator\n end",
"def initialize(enumerable)\n @enumerable = enumerable\n end",
"def each\n # If the caching cursor is closed and was not fully iterated,\n # the documents we have in it are not the complete result set and\n # we have no way of completing that iteration.\n # Therefore, discard that cursor and start iteration again.\n # The case of the caching cursor not being closed and not having\n # been fully iterated isn't tested - see RUBY-2773.\n @cursor = if use_query_cache? && cached_cursor && (\n cached_cursor.fully_iterated? || !cached_cursor.closed?\n )\n cached_cursor\n else\n session = client.send(:get_session, @options)\n select_cursor(session).tap do |cursor|\n if use_query_cache?\n # No need to store the cursor in the query cache if there is\n # already a cached cursor stored at this key.\n QueryCache.set(cursor, **cache_options)\n end\n end\n end\n\n if use_query_cache?\n # If a query with a limit is performed, the query cache will\n # re-use results from an earlier query with the same or larger\n # limit, and then impose the lower limit during iteration.\n limit_for_cached_query = respond_to?(:limit) ? QueryCache.normalized_limit(limit) : nil\n end\n\n if block_given?\n # Ruby versions 2.5 and older do not support arr[0..nil] syntax, so\n # this must be a separate conditional.\n cursor_to_iterate = if limit_for_cached_query\n @cursor.to_a[0...limit_for_cached_query]\n else\n @cursor\n end\n\n cursor_to_iterate.each do |doc|\n yield doc\n end\n else\n @cursor.to_enum\n end\n end",
"def each_with_iterator\n\n iterator = get_iterator_fast\n while (iterator.has_next?)\n yield iterator.get_next, iterator if block_given?\n end\n \n end",
"def iterator\n AlphabeticalOrderIterator.new(@collection)\n end",
"def iterator?() end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def iterator\n @table.iterator\n end",
"def key_iterator\n HashTableIterator.new(@table, false)\n end",
"def inorder_iterator\n InorderIterator.new(@root)\n end",
"def iterate(iterator)\n\tloop do\n\t\tyield iterator.next\n\tend\nend",
"def initialize(source)\n @source = source\n @iterable = iterable_from_source(source)\n end",
"def infinite_iterator(array)\n Enumerator.new do |result|\n loop do\n array.cycle { |item| result << item }\n end\n end\nend",
"def cons()\n Enumerator.new do |out|\n s = self.ensure_enum\n loop do\n items = s.next.ensure_enum\n loop do\n out.yield items.next\n end\n end\n end\n end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def initialize( *items )\n\t\tif items.length == 1 && items[0].is_a?( Enumerable )\n\t\t\t@items = items[0]\n\t\telse\n\t\t\t@items = items\n\t\tend\n\n\t\t@iteration = nil\n\t\t@lastItem = nil\n\t\t@item \t = nil\n\t\t@nextItem = nil\n\t\t@iterating = false\n\t\t@skipped = false\n\t\t@marker = nil\n\tend",
"def each\n raise ResultsAlreadyConsumedException unless @unread\n\n if block_given?\n @unread = false\n @source.each { |row| yield symbolize_row_keys(row) }\n else\n Enumerator.new(self)\n end\n end",
"def enumerator\n Enumerator.new do |yielder|\n response = get_initial_response\n\n loop do\n items = response.records\n\n # If there are no records, we're done\n break if items.empty?\n\n # Otherwise, iterate through the records...\n items.each { |item| yielder << item }\n\n # ...and fetch the next page\n @params ||= {}\n @params[:page] ||= 1\n @params[:page] += 1\n\n response = @service.list(**@params)\n end\n end.lazy\n end",
"def iterator()\n return TreeMapIterator.new(@tree)\n end",
"def batch_iterator\n Unipept::BatchIterator.new(batch_size)\n end",
"def iterator\n return HashTabletIterator.new(@table)\n end",
"def enumerator ; end",
"def enumerator ; end",
"def initialize\n yield self if block_given?\n end",
"def initialize\n yield self if block_given?\n end",
"def each\n raise StopIteration.new if closed?\n loop do\n document = try_next\n yield document if document\n end\n rescue StopIteration\n return self\n end",
"def enumerator; end",
"def lazy_init\n # build index clause if possible\n @index_clause,@where_clause = create_filter @where_expression\n hop_warn \"INDEX: #{@index_clause.inspect}\"\n if @index_clause and @push_index\n ind_iter = IndexedIterator.new(@db, @collection, @index_clause, @where_clause, @parent, @current_var)\n @enumerator = ind_iter.to_enum(:each)\n hop_warn \"index pushed to Mongo #{@where_expression.to_s}\"\n else\n ind_iter = IndexedIterator.new(@db, @collection, nil, @where_clause, @parent, @current_var)\n @enumerator = ind_iter.to_enum(:each)\n hop_warn 'index not pushed to Mongo' if @where_expression\n end\n end",
"def rewind\n @recur_iterator.rewind\n # re-creating overridden event index.\n index = {}\n @overridden_events.each_with_index do |event, key|\n stamp = event['DTSTART'].date_time(@time_zone).to_i\n index[stamp] = key\n end\n index = index.to_a.sort { |a, b| b[0] <=> a[0] }.to_h\n @counter = 0\n @overridden_events_index = index\n @current_overridden_event = nil\n\n @next_date = nil\n @current_date = @start_date.clone\n\n self.next\n end",
"def next\n g = __generator\n begin\n g.next\n rescue EOFError\n raise StopIteration, 'iteration reached at end'\n end\n end",
"def each\n\t\titems = @items.dup\n\t\t@items = @items.entries\n\t\traise LocalJumpError, \"no block given\" unless block_given?\n\n\t\t#self.log.debug \"Iterating over @items = %p\" % [ @items ]\n\n\t\t# Save this point so #restart can jump back here later. This is in a\n\t\t# loop because it needs to be remade after it's used the first time.\n\t\tuntil @marker\n\t\t\t@marker = callcc {|cc| cc}\n\t\tend\n\t\t@iterating = true\n\t\t@iteration = 0\n\n\t\t# Mark the outer loop for #break\n\t\tcatch( :break ) {\n\t\t\tuntil @iteration >= @items.length\n\n\t\t\t\t# Catch a skip with the number of items to skip. Unskipped\n\t\t\t\t# iterations \"skip\" 0 items.\n\t\t\t\tn = catch( :skip ) {\n\t\t\t\t\t@lastItem\t= self.first? ? nil : @items[ @iteration - 1 ]\n\t\t\t\t\t@item\t\t= @items[ @iteration ]\n\t\t\t\t\t@nextItem\t= self.last? ? nil : @items[ @iteration + 1 ]\n\n\t\t\t\t\tif @item.is_a?( Array )\n\t\t\t\t\t\tyield( self, *@item )\n\t\t\t\t\telse\n\t\t\t\t\t\tyield( self, @item )\n\t\t\t\t\tend\n\n\t\t\t\t\t0\n\t\t\t\t}\n\n\t\t\t\t# Set the skipped flag for next iteration if we're skipping\n\t\t\t\t@skipped = n.nonzero?\n\t\t\t\t@iteration += n + 1\n\t\t\tend\n\t\t}\n\n\t\t#self.log.debug \"Returning from Iterator#each\"\n\n\t\treturn @items\n\tensure\n\t\t@items\t\t= items\n\t\t@iteration\t= nil\n\t\t@lastItem\t= nil\n\t\t@item\t\t= nil\n\t\t@nextItem\t= nil\n\t\t@iterating\t= false\n\t\t@skipped\t= false\n\t\t@marker\t\t= nil\n\tend",
"def initialize(&block)\n yield self\n end",
"def version_iterator\n VersionIterator.new.version(self)\n end",
"def each\n page = Page.new @uri, @filters, @headers\n until page.nil?\n yield page\n page = page.next\n end\n end",
"def consumer\n @consumer ||= ::Enumerator.new(@enumerable)\n end",
"def each\n check_closed\n\n if block_given?\n begin\n scanner = htable.getScanner(filtered_scan)\n scanner.each do |result|\n yield Result.send(:new, result)\n end\n ensure\n scanner.close if scanner\n end\n else\n self\n end\n end",
"def next\n\t\t@skip = (@skip || 0) + get_resultcount\n\t\t@result = nil\n\t\treturn self\n\tend",
"def collection\n iterator.next\n end",
"def next\n raise StopIteration if @enumerators.empty?\n minimum_enumrator.next\n end",
"def initialize\n yield( self ) if block_given? # allow setup with code block\n end",
"def iterate\n raise \"You should implement this\"\n end",
"def initialize(&block)\n yield self\n end",
"def each( &block )\n if block_given?\n entries.each{ |id,entry| yield Entry.new(self,id,entry) }\n else\n Enumerator.new(self, :each)\n end\n end",
"def each(&block)\n return enum_for(:each) unless block_given?\n \n # if using the block form only, don't \"next\" for internal iteration\n if @block && !@enum\n @block.call Enumerator::Yielder.new(&block)\n else\n rewind\n\n until end?\n yield self.next\n end\n end\n \n self\n end",
"def each_raw\n iterator.each { |i| yield i }\n end",
"def initialize(enum = nil, &block)\n warning \"Using inefficient threaded enumerator for #{enum.inspect}, consider writing a iterator\" if $DEBUG\n @queue_finalizer = QueueFinalizer.new\n ObjectSpace.define_finalizer self, &@queue_finalizer\n _setup(enum, block)\n end",
"def each\n enum = cursor.to_enum\n enum.each do |doc|\n yield doc\n end if block_given?\n enum\n end",
"def initialize(&block)\r\n yield(self) if block_given? \r\n end",
"def each\n return to_enum(:each) unless block_given?\n\n seek(:head)\n yield current_entry while move_next\n end",
"def initialize(object = nil, enum_sel = :each, *extra)\n # per specs, requires 1.8.8 or above\n unless object\n if block_given?\n raise(ArgumentError, 'Enumerator from block not supported in 1.8.7')\n else\n raise(ArgumentError, 'wrong number of arguments (0 for 1)')\n end\n end\n\n @ofs = 0\n @obj = object\n unless enum_sel._isSymbol\n raise TypeError, 'second arg must be a Symbol'\n end\n @enum_selector = enum_sel\n @extra_args = extra\n end",
"def rewind\n @tree_iterator.rewind\n end",
"def initialize(turtletext_reader,&block)\n @reader = turtletext_reader\n @page = 1\n @inclusive = false\n if block_given?\n if block.arity == 1\n yield self\n else\n instance_eval &block\n end\n end\n end",
"def initialize(*)\n super\n yield self if block_given?\n end",
"def iterate seed, &block\n Enumerator.new do |e|\n current = seed\n loop do\n e << current\n current = yield current\n end\n end\nend",
"def initialize\n start\n if block_given?\n yield\n stop\n end\n end",
"def each()\n yield izq\n yield der\n end",
"def each\n return to_enum unless block_given?\n\n yield header\n input.each do |item|\n yield xml(item)\n end\n yield footer\n\n self\n end",
"def rewind\n @object.rewind if @object.respond_to? :rewind\n @generator.rewind if @generator\n @lookahead = []\n self\n end",
"def each\n return enum_for(:each) unless block_given?\n\n pointer = self\n loop do\n break if pointer.null?\n yield pointer\n pointer = pointer.next\n end\n end",
"def each\n while items = next_page\n break if items.empty?\n items.each do |item|\n yield item\n end\n end\n self\n end",
"def initialize(enumerable, **options)\n @dataset = enumerable\n end",
"def lazy_read(file)\n Enumerator.new do |yielder|\n CSV.foreach(file, DEFAULT_CSV_OPTIONS) do |row|\n yielder.yield(row)\n end\n end\n end",
"def each\n @collection.each { |c| yield c }\n end",
"def init\n if @dir_path\n @gen = Resource[@dir_path].entries.to_enum\n else\n @gen = [].each\n end\n end",
"def iter()\n if @handle.ptr == nil\n raise \"this is disposed\"\n end\n result = SegmentHistoryIter.new(Native.SegmentHistory_iter(@handle.ptr))\n result\n end",
"def each(&block)\n if block_given?\n iterate_documents{ |doc| yield(doc) }\n else\n Enumerator.new do |y|\n iterate_documents{ |doc| y.yield(doc) }\n end\n end\n end",
"def initialize(enumerable = [])\n @sem = Mutex.new\n @store = Tempfile.new(\"obuf\")\n @store.binmode\n @size = 0\n \n @lens = Obuf::ProtectedLens.new(@store)\n \n # Store everything from the enumerable in self\n enumerable.each { |e| push(e) }\n \n # ...and yield self for any configuration\n yield self if block_given?\n end",
"def each_index(&block)\n enum = Enumerator.new do |yielder|\n begin\n @each_index = {}\n\n count = 0\n self.each do |ele|\n # Remove previous element to not take up memory.\n count_before = count - 1\n @each_index.delete(count_before) if @each_index.key?(count_before)\n\n # Add current element to cache.\n @each_index[count] = ele\n yield(count)\n\n # Increase count for next run.\n count += 1\n end\n ensure\n @each_index = nil\n end\n end\n\n if block\n enum.each(&block)\n return nil\n else\n return enum\n end\n end",
"def iter?\n @type == :iter\n end",
"def iter?\n @type == :iter\n end",
"def each()\n i = 0\n while i < @total\n yield at(i)\n i += 1\n end\n self\n end",
"def lazy_read(file)\n Enumerator.new do |yielder|\n CSV.foreach(file, DEFAULT_CSV_OPTIONS) do |row|\n yielder.yield(row)\n end\n end\n end",
"def use\n if !@open_func\n raise ArgumentError, \"FileEnumerator reused.\"\n end\n use_count_up\n begin\n yield\n ensure\n use_count_down\n end\n end",
"def test_generator\n g = Enumerator::Generator.new(Proc.new { 1 })\n g.to_a\n assert(true)\n end",
"def each # And define each on top of next\n loop { yield self.next }\n end",
"def each # And define each on top of next\n loop {yield self.next }\n end",
"def each\n\t\titerator = @head\n\t\twhile iterator != nil do\n\t\t\tyield iterator.value\n\t\t\titerator = iterator.next\n\t\tend\n\tend",
"def initialize(est)\n @iterate = est.iterate\n @total = est.total\n end",
"def initialize(reactor: nil, state: nil, input: nil, iteration_limit: nil)\n super()\n\n @reactor = reactor\n @input = input\n @state = state || self.initial_state\n @terminated = false\n @events = nil\n\n @iteration_limit = iteration_limit&.to_i\n\n yield(self) if (block_given?)\n end",
"def end_iterator\n ListIterator.new @tail, self\n end",
"def initialize(client, path, params = {}, &block)\n params[:limit] = 200\n params[:page] ||= 1\n params.delete(:offset)\n\n block ||= Proc.new { |item| item }\n response = client.get_with_params_retry(path, params, 3)\n\n @paged_enumerator = PagedEnumerator.new(response) do |response, yielder|\n response.body.each do |item|\n yielder << block.call(item)\n end\n total = response.headers[\"x-resultset-total\"].to_i\n limit = response.headers[\"x-resultset-limit\"].to_i\n page = response.headers[\"x-resultset-page\"].to_i\n pages_processed = page - 1\n count = response.body.length\n offset = pages_processed * limit\n\n if count == 0 || count + offset >= total\n false\n else\n client.get_with_params_retry(path, params.merge(page: page + 1), 3)\n end\n end\n end",
"def iiifables\n @iiifables ||= result.map { |item| item_klass.new(doc_hash: item) }\n end",
"def each\n return to_enum unless block_given?\n entries.each { |entry| yield(entry) }\n self\n end",
"def get_next\n\n if (@local_iterator)\n @local_iterator.get_next\n else\n raise \"No iterator defined! Cannot get next element\"\n end\n\n end",
"def each\n while row = next_row\n yield row\n end\n return self\n end",
"def iteration\n log.deprecated(log_key) do\n \"iteration (DSL). Please use build_iteration instead.\"\n end\n\n build_iteration\n end",
"def each\n\n rewind\n\n n,f,q,c=next_seq\n\n while (!n.nil?)\n yield(n,f,q,c)\n n,f,q,c=next_seq\n end\n\n rewind\n\n end"
] |
[
"0.7022715",
"0.7019512",
"0.6894122",
"0.6449395",
"0.63852686",
"0.62473184",
"0.6089897",
"0.58430946",
"0.5811757",
"0.57916164",
"0.5742037",
"0.57390785",
"0.57236403",
"0.56869006",
"0.56869006",
"0.56869006",
"0.56869006",
"0.5675764",
"0.5662358",
"0.56622213",
"0.5640265",
"0.5636185",
"0.5612361",
"0.56075096",
"0.5578517",
"0.5578517",
"0.5578517",
"0.5578517",
"0.5523333",
"0.5517775",
"0.5482018",
"0.5448402",
"0.5442268",
"0.54421276",
"0.53907305",
"0.53907305",
"0.53733987",
"0.53733987",
"0.5359664",
"0.53256524",
"0.53241736",
"0.5321179",
"0.5306169",
"0.53052235",
"0.5286741",
"0.5274473",
"0.5248827",
"0.52418643",
"0.52387226",
"0.5237175",
"0.52162266",
"0.5215142",
"0.51892966",
"0.51801974",
"0.5179491",
"0.5179428",
"0.51713616",
"0.51635",
"0.5137911",
"0.509882",
"0.50943184",
"0.5081037",
"0.507102",
"0.5066251",
"0.50645995",
"0.50564593",
"0.5055046",
"0.5048427",
"0.5047359",
"0.5038788",
"0.5030899",
"0.5014526",
"0.500003",
"0.49943438",
"0.49834472",
"0.4979548",
"0.4974812",
"0.49731666",
"0.49714503",
"0.49632996",
"0.4956275",
"0.49523333",
"0.49523333",
"0.49508393",
"0.49393895",
"0.4938752",
"0.4931928",
"0.4930933",
"0.49246162",
"0.49196562",
"0.49166694",
"0.49091056",
"0.49072123",
"0.4906601",
"0.4897758",
"0.48965597",
"0.48943698",
"0.48933265",
"0.4881967",
"0.4878096"
] |
0.7505006
|
0
|
End getter Method to create elevators
|
def makeElevator
for elevatorID in 1..@amountOfElevators
elevator = Elevator.new(elevatorID, 'idle', @amountOfFloors, 1)
@elevatorsList.push(elevator)
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def createElevatorsList\n for x in 1..@numberOfElevators do\n @elevatorsList.append(Elevator.new(x, @numberOfFloors, 1, ElevatorStatus::IDLE, SensorStatus::OFF, SensorStatus::OFF))\n # puts \"elevator#{@id} created\"\n end\n end",
"def initialize(elevators, request)\n @elevators = elevators\n @request = request\n end",
"def create_elevators\n @elevator_number.times do |i|\n floor_gap = @building.floors / @elevator_number * i\n elevator_list.append(Elevator.new(i, 1 + floor_gap, 1 + floor_gap))\n end\n end",
"def getMenu(menu)\n menu.add_item(\"Done\") {self.done}\n menu.add_item(\"Edit Camera...\") {self.edit}\n menu.add_item(\"Reset Tilt\") {self.reset_tilt}\nend",
"def create_elevator_list\n \n for elevatorID in 1..Column.num_elevators do\n elevator = Elevator.new(elevatorID)\n elevator.create_floor_buttons()\n @elevator_list.append(elevator)\n end\n end",
"def hero_right_arrow_button\n $tracer.trace(__method__)\n # unit_test_no_generate: hero_right_arrow_button, a.with.className(\"/(^|\\s+)rightArrow($|\\s+)/\").find.img\n return ToolTag.new(a.with.className(\"/(^|\\s+)rightArrow($|\\s+)/\").find.img, __method__, self)\n end",
"def gen_menu\n @menu = MenuTree.new\n\n return unless @sysuser\n\n @menu << MenuItem.new(_('Laboratories'),\n url_for(:controller => 'laboratories')) <<\n MenuItem.new(_('Profiles'),\n url_for(:controller => 'profiles')) <<\n MenuItem.new(_('Disk devices'),\n url_for(:controller => 'disk_devs')) <<\n MenuItem.new(_('Terminals'),\n url_for(:controller => 'terminals')) <<\n MenuItem.new(_('Terminal classes'),\n url_for(:controller => 'term_classes')) <<\n MenuItem.new(_('Instances'),\n url_for(:controller => 'instances')) \n\n if @sysuser.admin?\n @menu << MenuItem.new(_('User management'),\n url_for(:action => 'list', \n :controller => 'sysusers'))\n end\n end",
"def hero_left_arrow_button\n $tracer.trace(__method__)\n # unit_test_no_generate: hero_left_arrow_button, a.id(\"leftArrowTest\").find.img\n return ToolTag.new(a.id(\"leftArrowTest\").find.img, __method__, self)\n end",
"def createMenu _obj, _args\n \"_obj createMenu _args;\" \n end",
"def create_enemy_window() end",
"def create_menu\n h = { f: :create_a_file,\n d: :create_a_dir,\n s: :create_dir_with_selection,\n b: :create_bookmark }\n _, menu_text = menu 'Create Menu', h\nend",
"def main_menu\n h = {\n a: :ag,\n z: :z_interface,\n # f: :file_actions,\n b: :bookmark_menu,\n c: :create_menu,\n f: :filter_menu,\n o: :order_menu,\n s: :selection_menu,\n t: :toggle_menu,\n v: :view_menu,\n '`' => :goto_parent_dir,\n x: :extras\n }\n menu 'Main Menu', h\nend",
"def level1_eg\r\n\r\n end",
"def TreeView_GetIndent(hwnd) send_treeview_message(hwnd, :GETINDENT) end",
"def nMenuItems _obj, _args\n \"_obj nMenuItems _args;\" \n end",
"def create_menus\n @file_menu = menu_bar.add_menu(tr(\"&File\"))\n @currency_menu = menu_bar.add_menu(tr(\"&Currency\"))\n @currency_menu.add_action(@import_file_action)\n @currency_menu.add_action(@import_url_action)\n @token_menu = menu_bar.add_menu(tr(\"&Token\"))\n @token_menu.add_action(@verify_action)\n @token_menu.add_action(@reissue_action)\n menu_bar.add_separator\n @help_menu = menu_bar.add_menu(tr(\"&Help\"))\n @help_menu.add_action(@about_action)\n end",
"def role_hierarchy\n [:visitor, :data_entry, :editor, :admin]\n end",
"def menu_items\n\n menu.items(self)\n\n end",
"def lru_elevator\n\t\televator = elevators.shift\n\t\televators.push(elevator)\n\t\televator\n\tend",
"def create_menu_command\n\t @command_window = Window_MenuCommand.new\n\t @command_window.set_handler(:item, method(:command_item))\n\t @command_window.set_handler(:skill, method(:command_personal))\n\t @command_window.set_handler(:equip, method(:command_personal))\n\t @command_window.set_handler(:status, method(:command_personal))\n\t @command_window.set_handler(:save, method(:command_save))\n\t @command_window.set_handler(:game_end, method(:command_game_end))\n\t @command_window.set_handler(:cancel, method(:return_scene))\t\n\tend",
"def default_context_menu\n [\n :row_counter.action,\n \"-\",\n :ctrl_manage.action,\n :show_details.action, # The custom action defined below via JS\n \"-\", # Adds a separator\n *super # Inherit all other commands\n ]\n end",
"def build_automate_tree(type)\n tree_name = \"#{type}_tree\".to_sym\n\n # build the ae tree to show the tree select box for entry point\n if x_active_tree == tree_name && @edit && @edit[:new][:fqname]\n nodes = @edit[:new][:fqname].split(\"/\")\n @open_nodes = []\n # if there are more than one nested namespaces\n nodes.each_with_index do |_node, i|\n if i == nodes.length - 1\n # check if @cls is there, to make sure the class/instance still exists in Automate db\n inst = @cls ? MiqAeInstance.find_by(:class_id => @cls.id, :name => nodes[i]) : nil\n # show this as selected/expanded node when tree loads\n if inst\n @open_nodes.push(\"aei-#{inst.id}\")\n @active_node = \"aei-#{inst.id}\"\n end\n elsif i == nodes.length - 2\n @cls = MiqAeClass.find_by(:namespace_id => @ns.id, :name => nodes[i])\n @open_nodes.push(\"aec-#{@cls.id}\") if @cls\n else\n @ns = MiqAeNamespace.find_by(:name => nodes[i])\n @open_nodes.push(\"aen-#{@ns.id}\") if @ns\n end\n end\n end\n\n klass = case type\n when :automate\n TreeBuilderAutomate\n when :automate_catalog\n TreeBuilderAutomateCatalog\n end\n\n @automate_tree = klass.new(tree_name, @sb)\n end",
"def menu_items\n menu.items(self)\n end",
"def menu_items\n menu.items(self)\n end",
"def TreeView_GetEditControl(hwnd) send_treeview_message(hwnd, :GETEDITCONTROL) end",
"def vers_menu\n @win.set_title(\"FILL A PIX\")\n @win.set_default_size($widthEcran, $heightEcran)\n \n @win.remove(@layoutManager)\n\n Ecran_menu.creer(@win)\n return self\n end",
"def pencil\n @application.pencil\n end",
"def build_menu(type)\n # Session Gtk::Menu\n menu_session = Gtk::Menu.new\n\n session_item_shell = Gtk::ImageMenuItem.new(\"Interact Session\")\n session_image_shell = Gtk::Image.new\n session_image_shell.set(Gtk::Stock::CONNECT, Gtk::IconSize::MENU)\n session_item_shell.set_image(session_image_shell)\n menu_session.append(session_item_shell)\n\n if (type == \"meterpreter\")\n meterpreter_separator = Gtk::SeparatorMenuItem.new\n menu_session.append(meterpreter_separator)\n\n # Meterpreter shell\n meterpreter_item_shell = Gtk::ImageMenuItem.new(\"Meterpreter Shell\")\n meterpreter_image_shell = Gtk::Image.new\n meterpreter_image_shell.set(Gtk::Stock::EXECUTE, Gtk::IconSize::MENU)\n meterpreter_item_shell.set_image(meterpreter_image_shell)\n # TODO\n # menu_session.append(meterpreter_item_shell)\n\n # sdapi/process\n meterpreter_proc_item_shell = Gtk::ImageMenuItem.new(\"Process\")\n meterpreter_proc_image_shell = Gtk::Image.new\n meterpreter_proc_image_shell.set(Gtk::Stock::INDEX, Gtk::IconSize::MENU)\n meterpreter_proc_item_shell.set_image(meterpreter_proc_image_shell)\n menu_session.append(meterpreter_proc_item_shell)\n\n # sdapi/fs\n meterpreter_fs_item_shell = Gtk::ImageMenuItem.new(\"Browse\")\n meterpreter_fs_image_shell = Gtk::Image.new\n meterpreter_fs_image_shell.set(Gtk::Stock::OPEN, Gtk::IconSize::MENU)\n meterpreter_fs_item_shell.set_image(meterpreter_fs_image_shell)\n menu_session.append(meterpreter_fs_item_shell)\n\n # Meterpreter shell signal\n meterpreter_item_shell.signal_connect('activate') do |item|\n if current = @selection.selected\n Msf::Ui::Gtk2::Console::Meterpreter.new(current)\n end\n end\n\n # Process signal\n meterpreter_proc_item_shell.signal_connect('activate') do |item|\n if current = @selection.selected\n Msf::Ui::Gtk2::Stdapi::Sys::Ps.new(current[O_SESSION])\n end\n end\n\n # Fs signal\n meterpreter_fs_item_shell.signal_connect('activate') do |item|\n if current = @selection.selected\n Msf::Ui::Gtk2::Stdapi::Fs.new(current[O_SESSION])\n end\n end\n end\n\n basic_separator = Gtk::SeparatorMenuItem.new\n menu_session.append(basic_separator)\n\n close_session_item_shell = Gtk::ImageMenuItem.new(\"Close Session\")\n close_session_image_shell = Gtk::Image.new\n close_session_image_shell.set(Gtk::Stock::CLOSE, Gtk::IconSize::MENU)\n close_session_item_shell.set_image(close_session_image_shell)\n menu_session.append(close_session_item_shell)\n\n session_item_shell.signal_connect('activate') do |item|\n if current = @selection.selected\n open_session(current)\n end\n end\n\n close_session_item_shell.signal_connect('activate') do |item|\n if session_iter = @selection.selected\n remove_session_iter(session_iter)\n end\n end\n\n return menu_session.show_all\n end",
"def system_menu\n reply = []\n\n reply << if current_user == User.anonymous\n MenuItem.new('Sign In', new_session_path)\n else\n MenuItem.new('Profile', current_user)\n end\n\n reply += [\n MenuItem.new('Dashboard', admin_root_path),\n MenuItem.new('Content', admin_nodes_path, [\n MenuItem.new('New', new_admin_node_path, ScratchPad::Addon::NodeExtension.enabled.sort.map { |extension|\n MenuItem.new(extension.title, new_admin_node_path(:node_type => extension.machine_name))\n })\n ]),\n MenuItem.new('Taxonomy', admin_vocabularies_path, [\n MenuItem.new('New', new_admin_vocabulary_path)\n ]),\n MenuItem.new('Filters', admin_filter_groups_path, [\n MenuItem.new('New', new_admin_filter_group_path)\n ]),\n MenuItem.new('Themes', admin_themes_path, [\n MenuItem.new('Frontend', admin_themes_path(:scope => :frontend)),\n MenuItem.new('Backend', admin_themes_path(:scope => :backend))\n ]),\n MenuItem.new('Users', admin_users_path, [\n MenuItem.new('New', new_admin_user_path)\n ]),\n MenuItem.new('Groups'),\n MenuItem.new('Permissions'),\n MenuItem.new('Settings', admin_settings_path),\n MenuItem.new('Addon Configuration', admin_addon_configurations_path, ScratchPad::Addon::Base.addon_types.map { |addon_type|\n MenuItem.new(addon_type.title.pluralize, admin_addon_configurations_path(addon_type.machine_name))\n })\n ] if authorize\n\n reply\n end",
"def all_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(@menu_tag.find.div.className(\"mm-content-base\").find.a.className(\"mainButton\"), format_method(__method__))\n end",
"def elevate_priviledges\n old_authentication_level = SecurityContextHolder.getContext().getAuthentication()\n SecurityContextHolder.getContext().setAuthentication(ACL::SYSTEM)\n old_authentication_level\n end",
"def create_child\n Walker.new(x, y, direction + 2*rand(2) - 1)\n end",
"def wander\n perturb_direction\n walk\n end",
"def add_elevators(starting_floor, number_of_elevators)\n\t\tnumber_of_elevators.times do\n\t\t\te = Elevator.new(starting_floor, @elevator_strategy)\n\t\t\t@elevators << e\n\t\t\t@sim.register(e)\n\t\tend\n\tend",
"def menu_options\n raise Puerto::AbstractMethodError\n end",
"def proper_direction(direction)\n proper_direction_elevators = self.elevators.reject{|e| e.direction != direction }\n end",
"def path\n html = ''\n a = []\n m = DcBigMenu.find( @parent.page.menu_id )\n a << m\n while m.parent \n m = DcBigMenu.find( m.parent )\n a << m\n end\n# \n (a.size - 1).downto(0) do |i| \n html << \"<span id=menu-path-#{a.size - 1 - i}>\"\n html << link_4menu(a[i]) \n html << (i > 0 ? ' » ' : '') #›➔\n html << '</span>'\n end\n# Save level to parents params object\n @parent.params[:menu_level] = a.size\n html\nend",
"def elevations\n if (elems = self.points.first.elems) && elems.has_key?('ele')\n self.points.map { |p| p.elems['ele'] }\n else\n nil\n end\n end",
"def aria_role; end",
"def admin_level\n 5\n end",
"def menu # can do custom methods within a method/class\n end",
"def modifier; end",
"def create_line_item_button\n self.get_element(@browser, 'create')\n end",
"def idle\n self.elevators.reject{|e| !e.idle }\n end",
"def _menu_arrow\n b = Bitmap.new(16, 9)\n c1 = Color.new(0, 0, 0)\n c2 = Color.new(255, 255, 255)\n c3 = Color.new(127, 127, 127)\n b.fill_rect(7, 0, 2, 1, c2)\n b.set_pixel(6, 1, c2)\n b.fill_rect(7, 1, 1, 7, c3)\n b.fill_rect(8, 1, 1, 7, c1)\n b.set_pixel(9, 1, c2)\n b.set_pixel(5, 2, c2)\n b.fill_rect(6, 2, 1, 6, c3)\n b.fill_rect(9, 2, 1, 6, c1)\n b.set_pixel(10, 2, c2)\n b.set_pixel(4, 3, c2)\n b.fill_rect(5, 3, 1, 5, c3)\n b.fill_rect(10, 3, 1, 5, c1)\n b.set_pixel(11, 3, c2)\n b.set_pixel(3, 4, c2)\n b.fill_rect(4, 4, 1, 4, c3)\n b.fill_rect(11, 4, 1, 4, c1)\n b.set_pixel(12, 4, c2)\n b.set_pixel(2, 5, c2)\n b.fill_rect(3, 5, 1, 3, c3)\n b.fill_rect(12, 5, 1, 3, c1)\n b.set_pixel(13, 5, c2)\n b.set_pixel(1, 6, c2)\n b.fill_rect(2, 6, 1, 2, c3)\n b.fill_rect(13, 6, 1, 2, c1)\n b.set_pixel(14, 6, c2)\n b.set_pixel(0, 7, c2)\n b.set_pixel(1, 7, c3)\n b.set_pixel(14, 7, c1)\n b.set_pixel(15, 7, c2)\n b.fill_rect(1, 8, 14, 1, c2)\n return b\n end",
"def intentions_for_next_step\n super + [@wander_intention]\n end",
"def add_self_to_getters(right_elements); end",
"def elevator\n elevators.sort_by { |e| e.stop_count }.first\n end",
"def TreeView_GetExtendedStyle(hwnd) send_treeview_message(hwnd, :GETEXTENDEDSTYLE) end",
"def create_menu\n items = Hash.new\n # action shd be a hash\n # menu should have array of hashes (or just a string)\n #db = { :name => \"Databases\", :accelerator => \"M-d\", :enabled = true, :on_right => :get_databases }\n #or = { :name => \"Open Recent\", :accelerator => \"M-o\", :enabled = true, :on_right => :get_recent }\n #find_array = {\"Find ...\" => :find, \"Find Next\" => :find_next, \"Find Previous\" => :find_prev}\n items[\"File >\"] = [\"Open ... C-o\" , \"Open Recent\", \"Databases\" , \"Tables\", \"Exit\"]\n items[\"Window >\"] = { \"Tile\" => nil, \"Find >\" => {\"Find ...\" => :find, \"Find Next\" => :find_next, \"Find Previous\" => :find_prev},\n \"Edit\" => nil, \"Whatever\" => nil}\n items[\"Others >\"] = { \"Shell Output ...\" => :shell_output, \"Suspend ...\" => :suspend , \"View File\" => :choose_file_and_view}\n\n # in the case of generated names how will call back know that it is a db name or a table name\n # We get back an array containing the entire path of selections\n right_actions = {}\n right_actions[\"Databases\"] = Proc.new { Dir.glob(\"**/*.{sqlite,db}\") }\n right_actions[\"Tables\"] = :get_table_names\n\n ret = popupmenu items, :row => 1, :col => 0, :bgcolor => :cyan, :color => :white, :right_actions => right_actions\n # ret can be nil, or have a symbol to execute, or a String for an item with no leaf/symbol\n if ret\n alert \"Got #{ret}\"\n last = ret.last\n if last.is_a? Symbol\n if respond_to?(last, true)\n send(last)\n end\n end\n end\n\n return\n r = 1\n ix = popuplist( top , :title => \" Menu \" , :row => r, :col => 0, :bgcolor => :cyan, :color => :white)\n if ix\n value = top[ix]\n ix = popuplist( items[value] , :row => r + 2 + ix, :col => 10, :bgcolor => :cyan, :color => :white)\n end\nend",
"def createMenuItems(invocation)\n\n menu = []\n\n # Which part of the interface the user selects\n ctx = invocation.getInvocationContext()\n\n # Sitemap history, Proxy History, Request views, and Scanner will show menu item if selected by the user\n #@stdout.println('Menu TYPE: %s\\n' % ctx)\n if ctx == 5 or ctx == 6 or ctx == 2 or ctx == 7\n\n \t faradayMenu = JMenuItem.new(\"Send to Faraday\", nil)\n\n \t faradayMenu.addActionListener do |e|\n \t eventScan(invocation, ctx)\n \t end\n\n \t menu.push(faradayMenu)\n end\n\n return menu\n end",
"def tool_1\n @@mse = Proc.new { |up_down_dbl, flags, x, y, view|\n button = ''\n key_mod = ''\n if (MK_LBUTTON & flags != 0) then button << ', Left' end\n if (MK_MBUTTON & flags != 0) then button << ', Middle' end\n if (MK_RBUTTON & flags != 0) then button << ', Right' end\n\n if (MK_SHIFT & flags != 0) then key_mod << ', Shift' end\n if (MK_CONTROL & flags != 0) then key_mod << ', Ctrl' end\n if (MK_ALT & flags != 0) then key_mod << ', Alt' end\n s1 = up_down_dbl.ljust(7)\n s2 = button.sub(/^, /, '').ljust(20)\n s3 = key_mod.sub(/^, /, '')\n puts \"Mouse Button #{s1} button = #{s2} keys = #{s3}\"\n }\n @tool = Object.new\n @tool.instance_eval {\n def onLButtonDown(*a) ; @@mse.call('Down' , *a) ; end\n def onMButtonDown(*a) ; @@mse.call('Down' , *a) ; end\n def onRButtonDown(*a) ; @@mse.call('Down' , *a) ; end\n\n def onLButtonUp(*a) ; @@mse.call('Up' , *a) ; end\n def onMButtonUp(*a) ; @@mse.call('Up' , *a) ; end\n def onRButtonUp(*a) ; @@mse.call('Up' , *a) ; end\n\n def onLButtonDoubleClick(*a) ; @@mse.call('DblClk', *a) ; end\n def onMButtonDoubleClick(*a) ; @@mse.call('DblClk', *a) ; end\n def onRButtonDoubleClick(*a) ; @@mse.call('DblClk', *a) ; end\n\n def onKeyDown(key, repeat, flags, view)\n # Some binary fun for testing\n t = flags.to_s(2).rjust(16)\n bin = \"#{ t[-16,4]} #{ t[-12,4]} \" \\\n \"#{ t[ -8,4]} #{ t[ -4,4]}\".rjust(19)\n puts \"#{key.to_s.ljust(4)}\\t#{flags.to_s.ljust(5)}\\t#{bin}\"\n\n k = key.to_s.rjust(3)\n alt = (ALT_MODIFIER_MASK & key != 0).to_s.ljust(5)\n cons = (CONSTRAIN_MODIFIER_MASK & key != 0).to_s.ljust(5)\n copy = (COPY_MODIFIER_MASK & key != 0).to_s.ljust(5)\n puts \"key = #{k} alt = #{alt} cons = #{cons} copy = #{copy}\"\n end\n }\n Sketchup.active_model.select_tool(@tool)\n end",
"def native_atk\n actor.parameters[2, @level] + @atk_plus\n end",
"def computeNewMenu\n @NewMenu = Wx::Menu.new\n @Controller.getIntegrationPlugins.each do |iPluginID, iPluginInfo|\n lNewMenuItem = Wx::MenuItem.new(@NewMenu, Wx::ID_ANY, iPluginInfo[:Title])\n lNewMenuItem.bitmap = @Controller.getPluginBitmap(iPluginInfo)\n @NewMenu.append_item(lNewMenuItem)\n # The event\n # Clone variables to make them persistent in the Proc context\n lPluginIDCloned = iPluginID\n evt_menu(lNewMenuItem) do |iEvent|\n @Controller.accessIntegrationPlugin(lPluginIDCloned) do |iPlugin|\n @DisplayedList << [\n lPluginIDCloned,\n [],\n true,\n iPlugin.getDefaultOptions,\n [ nil, nil ]\n ]\n end\n refreshList\n end\n end\n end",
"def edit_modifier\n\n\tend",
"def create_menu\n @tk_root.tk_item.native_item.bind('Command-r', -> { main_component.execute_sql(nil) })\n end",
"def theatre_menu\n theatre = Menu.new(\"What would you like to do with theatres?\")\n theatre.add_menu_item({key_user_returns: 1, user_message: \"Create a theatre.\", do_if_chosen: [\"create_theatre\"]})\n theatre.add_menu_item({key_user_returns: 2, user_message: \"Update a theatre.\", do_if_chosen: [\"update_object\", Location, \"theatre_menu\"]})\n theatre.add_menu_item({key_user_returns: 3, user_message: \"Show me theatres.\", do_if_chosen: [\"show_object\", Location, \"theatre_menu\"]})\n theatre.add_menu_item({key_user_returns: 4, user_message: \"Delete a theatre.\", do_if_chosen: [\"delete_object\", Location, \"theatre_menu\"]})\n theatre.add_menu_item({key_user_returns: 5, user_message: \"Return to main menu.\", do_if_chosen: \n [\"main_menu\"]})\n run_menu_and_call_next(theatre)\n end",
"def xtra_points_menu_link\n $tracer.trace(__method__)\n return ToolTag.new(a.className(create_ats_regex_string(\"AuthorizedFaq\")), __method__)\n end",
"def addMenu _obj, _args\n \"_obj addMenu _args;\" \n end",
"def assigned_menu\n\n end",
"def call_elevator elevator_number=0\n\t\t@elevators[elevator_number].add_to_floors_to_visit @floor_number\n\tend",
"def auto_elevate!\n add_role :superuser\n end",
"def permissions_menu(name, text) #, target_class)\n define_method(name) {\n self.link(:text=>text).fire_event(\"onmouseover\")\n self.link(:text=>text).parent.div(:class=>\"lhnavigation_selected_submenu_image\").fire_event(\"onclick\")\n self.link(:id=>\"lhnavigation_submenu_user_permissions\").click\n self.class.class_eval { include ProfilePermissionsPopUp }\n }\n end",
"def main_menu\n\n# Step 1, create the entries with (display text, method(:to_be_called), optional_args)\n\n hello = GemMenu::Entry.new('hello', method(:hello_world))\n world = GemMenu::Entry.new('world', method(:counting_world))\n second_menu = GemMenu::Entry.new('2nd level', method(:menu_2))\n food_menu = GemMenu::Entry.new('food menu', method(:menu_favorite_foods))\n long = GemMenu::Entry.new('long menu', method(:long_menu))\n\n# Step 2, once entries are created, create the Menu object and return it with\n# (title text, array_of_Entries, optional_args)\n GemMenu::Menu.new('main menu', [hello, world, second_menu, food_menu, long])\nend",
"def create_extra_buttons()\n Rectangle.new(x:5,y:50,width:40,height:40,color:\"white\",z:1)\n Rectangle.new(x:16,y:66,width:18,height:9,color:\"#ff7eec\",z:1)\n Rectangle.new(x:5,y:100,width:40,height:40,color:\"white\",z:1)\n Rectangle.new(x:14,y:110,width:21,height:25,color:'#808080',z:1)\n Rectangle.new(x:14,y:110,width:21,height:5,color:'blue',z:1)\n Rectangle.new(x:5,y:150,width:40,height:40,color:\"white\",z:1)\n Triangle.new(x1:15,x2:35,x3:25,y1:180,y2:180,y3:160,color:\"black\",z:1)\n Rectangle.new(x:5,y:200,width:40,height:40,color:\"white\",z:1)\n Triangle.new(x1:15,x2:35,x3:25,y1:210,y2:210,y3:230,color:\"black\",z:1)\nend",
"def getMenu(menu)\n end",
"def my_account_menu_link\n $tracer.trace(__method__)\n return ToolTag.new(a.className(create_ats_regex_string(\"account\")), __method__)\n end",
"def createMenu\n\n # File menu\n recordAction = @actions.addNew(i18n('Start Download'), self, \\\n { :icon => 'arrow-down', :triggered => :startDownload })\n reloadStyleAction = @actions.addNew(i18n('&Reload StyleSheet'), self, \\\n { :icon => 'view-refresh', :shortCut => 'Ctrl+R', :triggered => :reloadStyleSheet })\n clearStyleAction = @actions.addNew(i18n('&Clear StyleSheet'), self, \\\n { :icon => 'list-remove', :shortCut => 'Ctrl+L', :triggered => :clearStyleSheet })\n quitAction = @actions.addNew(i18n('&Quit'), self, \\\n { :icon => 'application-exit', :shortCut => 'Ctrl+Q', :triggered => :close })\n\n updateScheduleAction = @actions.addNew(i18n('Update Schedule'), @scheduleWin, \\\n { :shortCut => 'Ctrl+U', :triggered => :updateAllFilters })\n\n fileMenu = KDE::Menu.new('&File', self)\n fileMenu.addAction(recordAction)\n fileMenu.addAction(reloadStyleAction)\n fileMenu.addAction(clearStyleAction)\n fileMenu.addAction(updateScheduleAction)\n fileMenu.addAction(quitAction)\n\n\n # settings menu\n playerDockAction = @playerDock.toggleViewAction\n playerDockAction.text = i18n('Show Player')\n configureAppAction = @actions.addNew(i18n('Configure %s') % APP_NAME, self, \\\n { :icon => 'configure', :shortCut => 'F2', :triggered => :configureApp })\n\n settingsMenu = KDE::Menu.new(i18n('&Settings'), self)\n settingsMenu.addAction(playerDockAction)\n settingsMenu.addSeparator\n settingsMenu.addAction(configureAppAction)\n\n\n # Help menu\n aboutDlg = KDE::AboutApplicationDialog.new(KDE::CmdLineArgs.aboutData)\n openAboutAction = @actions.addNew(i18n('About %s') % APP_NAME, self, \\\n { :icon => 'irecorder', :triggered =>[aboutDlg, :exec] })\n openDocUrlAction = @actions.addNew(i18n('Open Document Wiki'), self, \\\n { :icon => 'help-contents', :triggered =>:openDocUrl})\n openReportIssueUrlAction = @actions.addNew(i18n('Report Bug'), self, \\\n { :icon => 'tools-report-bug', :triggered =>:openReportIssueUrl })\n openRdocAction = @actions.addNew(i18n('Open Rdoc'), self, \\\n { :icon => 'help-contents', :triggered =>:openRdoc })\n openSourceAction = @actions.addNew(i18n('Open Source Folder'), self, \\\n { :icon => 'document-open-folder', :triggered =>:openSource })\n\n\n helpMenu = KDE::Menu.new(i18n('&Help'), self)\n helpMenu.addAction(openDocUrlAction)\n helpMenu.addAction(openReportIssueUrlAction)\n helpMenu.addAction(openRdocAction)\n helpMenu.addAction(openSourceAction)\n helpMenu.addSeparator\n helpMenu.addAction(openAboutAction)\n\n # insert menus in MenuBar\n menu = KDE::MenuBar.new\n menu.addMenu( fileMenu )\n menu.addMenu( settingsMenu )\n menu.addSeparator\n menu.addMenu( helpMenu )\n setMenuBar(menu)\n end",
"def menu(name, *args, &block)\n if self[name]\n self[name].extend(&block)\n else\n self[name] = Menu.new(nil, :menu, name, *args, &block)\n end\n end",
"def tralics_commands\n base_commands = <<-'EOS'\n% Commands specific to Tralics\n\\def\\hyperref[#1]#2{\\xmlelt{a}{\\XMLaddatt{target}{#1}#2}}\n\\newcommand{\\heading}[1]{\\xmlelt{heading}{#1}}\n\\newcommand{\\codecaption}[1]{\\xmlelt{heading}{#1}}\n\\newcommand{\\sout}[1]{\\xmlelt{sout}{#1}}\n\\newcommand{\\kode}[1]{\\xmlelt{kode}{#1}}\n\\newcommand{\\coloredtext}[2]{\\xmlelt{coloredtext}{\\AddAttToCurrent{color}{#1}#2}}\n\\newcommand{\\coloredtexthtml}[2]{\\xmlelt{coloredtexthtml}{\\AddAttToCurrent{color}{#1}#2}}\n\\newcommand{\\filepath}[1]{\\xmlelt{filepath}{#1}}\n\\newcommand{\\image}[1]{\\xmlelt{image}{#1}}\n\\newcommand{\\imagebox}[1]{\\xmlelt{imagebox}{#1}}\n% Ignore pbox argument, just replacing with content.\n\\newcommand{\\pbox}[2]{#2}\n% Ignore some other commands.\n\\newcommand{\\includepdf}[1]{}\n\\newcommand{\\newunicodechar}[2]{}\n\\newcommand{\\extrafloats}[1]{}\n EOS\n custom_commands = <<-EOS\n\\\\usepackage{amsthm}\n\\\\theoremstyle{definition}\n\\\\newtheorem{codelisting}{#{language_labels[\"listing\"]}}[chapter]\n\\\\newtheorem{aside}{#{language_labels[\"aside\"]}}[chapter]\n EOS\n [base_commands, custom_commands].join(\"\\n\")\n end",
"def default_context_menu\n [\n :row_counter.action,\n \"-\", # Adds a separator\n *super # Inherit all other commands\n ]\n end",
"def default_context_menu\n [\n :row_counter.action,\n \"-\", # Adds a separator\n *super # Inherit all other commands\n ]\n end",
"def TreeView_SetIndent(hwnd, indent) send_treeview_message(hwnd, :SETINDENT, wparam: indent) end",
"def addMenuItem _obj, _args\n \"_obj addMenuItem _args;\" \n end",
"def indented_child_options type, parent, depth=0, selected_id\n\n result = []\n unless parent.children.empty?\n parent.children.sort { |a, b| a.title.downcase <=> b.title.downcase }.each do |child|\n child_path = send(\"#{type.model_name.underscore}s_path\", :uri=>child.term_uri, :label=> child.title)\n assay_stat = child.assays.size == 0 ? \"\" : \"<span style='color: #666666;'>(#{child.assays.count} assays)</span>\".html_safe\n ontology_term_li = link_to(child.title, child_path).html_safe\n user_defined_term_li = link_to(child.title, child_path, {:style => \"color:green;font-style:italic\"}) + \"*\" + \" \" +\n (child.can_edit? ? link_to(image(\"edit\"), edit_polymorphic_path(child), {:style => \"vertical-align:middle\"}) : \"\") + \" \" +\n (child.can_destroy? ? (child.assays.count == 0 && child.children.empty? ? link_to(image(\"destroy\"), child, :confirm =>\n \"Are you sure you want to remove this #{child.class.name}? This cannot be undone.\",\n :method => :delete, :style => \"vertical-align:middle\") : \"\") : \"\").html_safe\n child_link = (child.respond_to?(:is_user_defined) && child.is_user_defined) ? user_defined_term_li : ontology_term_li\n\n result << (\"<li style=\\\"margin-left:#{12*depth}px;#{child.id == selected_id ? \"background-color: lightblue;\" : \"\"}\\\">\"+ (depth>0 ? \"└ \" : \" \") + child_link + assay_stat +\n \"</li>\")\n result = result + indented_child_options(type, child, depth+1,selected_id) if child.has_children?\n end\n end\n return result\n end",
"def privileges(user)\n\n\t\t# create a new privileges object with no rights\n\t\tp = TinyPrivileges.new\n\n\t\t# user must be specified\n\t\treturn p if user.nil?\n\n\t\t# an admin has full privileges\n\t\treturn p.grant_all if user.admin?\n\t\treturn p.grant_all if user == contract.facilitator\n\n\t\t##########################################\n\t\t# see if the user has an enrollment role on the contract here\n\t\tuser_role = contract.role_of(user)\n\n\t\t##########################################\n\t\t# USER IS NOT ENROLLED\n\t\t# if no role, then check for staff privileges\n\t\tif user_role.nil?\n\n\t\t\t# staff members can view and do notes\n\t\t\t# non-staff, non-enrolled user has no privileges\n\t\t\tp[:browse] = \n\t\t\tp[:view] = \n\t\t\tp[:create_note] = \n\t\t\tp[:view_students] = \n\t\t\tp[:view_note] = (user.privilege == User::PRIVILEGE_STAFF)\n\n\t\t\treturn p\n\t\tend\n\n\t\t##########################################\n\t\t# USER IS ENROLLED\n\t\t# FOR EDIT PRIVILEGES,\n\t\t# user must be instructor\n\t\tp[:edit] = (user_role >= Enrollment::ROLE_INSTRUCTOR)\n\t\t\n\t\t# FOR VIEW, NOTE PRIVILEGES,\n\t\t# user must be an instructor or a supervisor or the enrolled student\n\t\tp[:view] = \n\t\tp[:create_note] = \n\t\tp[:view_note] =\n\t\tp[:browse] = ((user_role >= Enrollment::ROLE_INSTRUCTOR) or\n\t\t\t\t\t\t\t\t\t(user.id == participant.id))\n\n\t\t# an instructor or supervisor can edit a note\n\t\tp[:view_students] = # bogus since an enrollment only deals with one student\n\t\tp[:edit_note] = user_role >= Enrollment::ROLE_INSTRUCTOR\n\t\treturn p\n\tend",
"def menu_for(parent, abstract_model = nil, object = nil, only_icon = true) # perf matters here (no action view trickery)\n actions = actions(parent, abstract_model, object).select { |a| a.http_methods.include?(:get) }\n actions.collect do |action|\n next unless authorized?(action.action_name, abstract_model)\n wording = wording_for(:menu, action)\n href_url = case action.action_name.to_s\n when \"export\"\n \"/admin/#{abstract_model.try(:to_param)}.xls\"\n when \"import\"\n \"/admin/#{abstract_model.try(:to_param)}/import\"\n else\n url_for(action: action.action_name, controller: 'rails_admin/main', model_name: abstract_model.try(:to_param), id: (object.try(:persisted?) && object.try(:id) || nil))\n end\n case action.key.to_s\n when \"new\"\n %(\n <li title=\"#{wording if only_icon}\" rel=\"#{'tooltip' if only_icon}\" class=\"icon #{action.key}_#{parent}_link #{'active' if current_action?(action)}\" style=\"float:left\">\n <a class=\"btn btn-primary\"}\" href=\"#{href_url}\">#{wording}</a>\n </li>\n )\n when \"import\"\n %(\n <li title=\"#{wording if only_icon}\" rel=\"#{'tooltip' if only_icon}\" class=\"icon #{action.key}_#{parent}_link #{'active' if current_action?(action)}\">\n <a class=\"#{action.pjax? ? 'pjax' : ''}\" href=\"#{href_url}\" style=\"float:left;\">\n <span>#{wording}</span>\n </a>\n </li>\n )\n when \"export\"\n %(\n <li title=\"#{wording if only_icon}\" rel=\"#{'tooltip' if only_icon}\" class=\"icon #{action.key}_#{parent}_link #{'active' if current_action?(action)}\" style=\"float:right\">\n <a class=\"#{action.pjax? ? 'pjax' : ''}\" href=\"#{href_url}\" style=\"float:left;\">\n <span>#{wording}</span>\n </a>\n </li>\n )\n when \"index\"\n else\n %(\n <li title=\"#{wording if only_icon}\" rel=\"#{'tooltip' if only_icon}\" class=\"icon #{action.key}_#{parent}_link #{'active' if current_action?(action)}\">\n <a class=\"#{action.pjax? ? 'pjax' : ''}\" href=\"#{href_url}\">\n <span>#{wording}</span>\n </a>\n </li>\n )\n end\n end.join.html_safe\n end",
"def set_elements\n super\n element(:message) {b.li(:class => 'uif-infoMessageItem')}\n element(:messages) {b.lis(:class => 'uif-infoMessageItem')}\n element(:message_header) {b.h3(:class => 'uif-pageValidationHeader')}\n element(:submit_button) {b.button(:id => \"submitEditor\")}\n element(:cancel_button) {b.button(:id => \"cancelEditor\")}\n element(:close_button) {b.button(:id => \"closeEditor\")}\n element(:return_to_search_button) {b.button(:id => \"returnToSearch_button\")}\n # Navigation Area Elements\n element(:delete_bib_button) {b.button(:title => 'Delete Bib')}\n element(:add_instance_button) {b.button(:title => 'Add Instance')}\n element(:add_einstance_button) {b.button(:title => 'Add EInstance')}\n # @note Vakata Context Menu items are only present on the screen after the containing menu header has been right-clicked.\n element(:delete_instance_button) {b.div(:id => 'vakata-contextmenu').ul.li(:index => 0).a(:rel => \"Delete\")}\n element(:add_item_button) {b.button(:title => 'Add Item')}\n element(:delete_item_button) {b.div(:id => 'vakata-contextmenu').ul.li(:index => 0).a(:rel => 'Delete')}\n end",
"def curatorMouseOver \n \"curatorMouseOver\" \n end",
"def right_js_unit_menu(unit)\n content_tag :ul, unit.unit_methods.all.collect { |method|\n menu_link_to(method.name, method)\n }\n end",
"def createMenuItems(invocation)\r\n \r\n menu = []\r\n\r\n # Which part of the interface the user selects\r\n ctx = invocation.getInvocationContext()\r\n\r\n # Sitemap history, Proxy History will show menu item if selected by the user\r\n @stdout.println('Menu TYPE: %s\\n' % ctx)\r\n if ctx == 5 or ctx == 6 or ctx == 7\r\n\r\n faradayMenu = JMenuItem.new(\"Send to Faraday\", nil)\r\n\r\n faradayMenu.addActionListener do |e|\r\n eventScan(invocation, ctx)\r\n end\r\n\r\n menu.push(faradayMenu)\r\n end\r\n \r\n return menu\r\n end",
"def to_html(html)\n traverse = lambda do |priv|\n output = '<li>'\n output << html.xml_name(priv['privilege'])\n output << ' <i>(abstract)</i>' unless priv['abstract'].blank?\n output << \" #{html.h(priv['description'])}\" if priv.key?('description')\n\n if priv.key?('aggregates')\n output << \"\\n<ul>\\n\"\n priv['aggregates'].each do |sub_priv|\n output << traverse.call(sub_priv)\n end\n output << '</ul>'\n end\n output << \"</li>\\n\"\n\n output\n end\n\n output = \"<ul class=\\\"tree\\\">\"\n output << traverse.call(@privileges)\n output << \"</ul>\\n\"\n\n output\n end",
"def menu_selection \nend",
"def create_command_window\n end",
"def legionnairs\n\n end",
"def main_command_window\r\n # Make command window\r\n s1 = SDK::Scene_Commands::Scene_Menu::Item\r\n s2 = SDK::Scene_Commands::Scene_Menu::Skill\r\n s3 = SDK::Scene_Commands::Scene_Menu::Equip\r\n s4 = SDK::Scene_Commands::Scene_Menu::Status\r\n s5 = SDK::Scene_Commands::Scene_Menu::Save\r\n s6 = SDK::Scene_Commands::Scene_Menu::End_Game\r\n @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6])\r\n @command_window.index = @menu_index\r\n # If number of party members is 0\r\n if $game_party.actors.size == 0\r\n # Disable items, skills, equipment, and status\r\n @command_window.disable_item(0)\r\n @command_window.disable_item(1)\r\n @command_window.disable_item(2)\r\n @command_window.disable_item(3)\r\n end\r\n # If save is forbidden\r\n if $game_system.save_disabled\r\n # Disable save\r\n @command_window.disable_item(4)\r\n end\r\n end",
"def create_path_edit\n\t\t\n\t\t\t# Create actual Path edit -- LineEditWithHint\n\t\t\t@path_edit = Qt::LineEditWithHint.new(\n\t\t\t\t@form.directoryEditPlaceholder.toolTip, @parent,\n\t\t\t\t{ \n\t\t\t\t\t:validate_callback => lambda { |path| check_path(path) },\n\t\t\t\t\t:done_callback => lambda { set_folder_icon(false) },\n\t\t\t\t :warn_text => @form.directoryEditPlaceholder.statusTip \n\t\t\t\t}\n\t\t\t)\n\t\t\t\t\n\t\t\t# 'Inherit' minimum size\n\t\t\t@path_edit.minimumSize = @form.directoryEditPlaceholder.minimumSize\n\t\t\t@path_edit.prepare_for_immediate_keypress\n\t\t\t\n\t\t\t# Remove placeholder and add actual (extended) widget\n\t\t\tGuiUtils.replace_grid_widget({\n\t\t\t\t:grid => @form.gridLayout, \n\t\t\t\t:old_widget => @form.directoryEditPlaceholder,\n\t\t\t\t:new_widget => @path_edit,\n\t\t\t\t:row => 0, :col => 1,\n\t\t\t\t:col_span => 2\n\t\t\t})\n\t\tend",
"def admin_menu \n @admin_menu ||= [\n ['overview', :dashboard, {controller: 'gricer/dashboard', action: 'overview'}],\n ['visitors', :menu, [\n ['entry_pages', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'entry_path'}],\n ['referers', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'referer_host'}],\n ['search_engines', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'search_engine'}],\n ['search_terms', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'search_query'}],\n ['countries', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'country'}],\n ['domains', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'domain'}],\n ['locales', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'requested_locale_major'}]\n ] ],\n ['pages', :menu, [\n ['views', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'path'}],\n ['hosts', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'host'}],\n ['methods', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'method'}],\n ['protocols', :spread, {controller: 'gricer/requests', action: 'spread_stats', field: 'protocol'}],\n ] ],\n ['browsers', :menu, [\n ['browsers', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'agent.name'}],\n ['operating_systems', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'agent.os'}],\n ['engines', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'agent.engine_name'}],\n ['javascript', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'javascript'}],\n ['java', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'java'}],\n ['silverlight', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'silverlight_major_version'}],\n ['flash', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'flash_major_version'}],\n ['screen_sizes', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'screen_size'}],\n ['color_depths', :spread, {controller: 'gricer/sessions', action: 'spread_stats', field: 'screen_depth'}]\n ] ]\n ]\n end",
"def initialize(x, y, width, height, depth)\n super(x, y, width, height, depth)\n self.opacity = 0\n self.openness = 0\n @index = -1\n @options = []\n @handler = {}\n @cursor_fix = false\n @cursor_all = false\n create_options\n create_contents\n draw_menu_layers\n deactivate\n @command = true\n @fade_time = 20\n end",
"def create_arrows\n bx, by = 80, 16\n bw, bh = 8, 16\n 2.times do |i|\n sprite = Sprite.new(@viewport2)\n sprite.bitmap = Bitmap.new(bw, bh)\n sx = (i == 0 ? bx : (bx + bw + bh)) # 0 for left, 1 for right arrow\n rect = Rect.new(sx, by + bw, bw, bh)\n sprite.bitmap.blt(0, 0, self.windowskin, rect)\n sprite.y = self.y + (window_height - bh) - spacing * 4 \n sprite.x = i == 0 ? self.x + 2 : self.x + window_width - bw\n @arrow_sprites.push(sprite.hide)\n end\n end",
"def view_menu\n h = {\n f: :select_from_visited_files,\n d: :select_from_used_dirs,\n b: :view_bookmarks,\n s: :list_selected_files,\n c: :child_dirs,\n r: :recent_files,\n t: :tree,\n e: :dirtree\n }\n menu 'View Menu', h\nend",
"def build_menu(application_name, method_names)\n #take array of method names and turn into menu\n puts \"#{application_name.humanize}\"\n method_names.each_with_index {|method_name, index| puts \"#{index + 1}: #{method_name.to_s.humanize}\"}\n puts \"\\nPlease enter your selection:\"\nend",
"def main_menu\n h = { \n :a => :ack,\n \"/\" => :ffind,\n :l => :locate,\n :v => :viminfo,\n :z => :z_interface,\n :d => :child_dirs,\n :r => :recent_files,\n :t => :dirtree,\n \"4\" => :tree,\n :s => :sort_menu, \n :F => :filter_menu,\n :c => :command_menu ,\n :B => :bindkey_ext_command,\n :M => :newdir,\n \"%\" => :newfile,\n :x => :extras\n }\n menu \"Main Menu\", h\nend",
"def modal_create_account_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(@tag.find.a.className(create_ats_regex_string(\"btn_negative\")), format_method(__method__))\n end",
"def demoExplorerList(t)\n height = t.font.metrics(:linespace) + 2\n height = 18 if height < 18\n\n t.configure(:showroot=>false, :showbuttons=>false, :showlines=>false,\n :itemheight=>height, :selectmode=>:extended, :wrap=>:window,\n :showheader=>false, :scrollmargin=>16,\n :xscrolldelay=>[500, 50], :yscrolldelay=>[500, 50])\n\n init_pics('small-*')\n\n if $HasColumnCreate\n t.column_create(:widthhack=>true)\n else\n t.column_configure(0, :widthhack=>true)\n end\n\n t.element_create('elemImg', :image,\n :image=>[\n @sel_images['small-folder'], ['selected'],\n @images['small-folder'], []\n ])\n t.element_create('elemTxt', :text, :lines=>1,\n :fill=>[@SystemHighlightText, ['selected', 'focus']])\n t.element_create('elemSel', :rect, :showfocus=>true,\n :fill=>[\n @SystemHighlight, ['selected', 'focus'],\n 'gray', ['selected', '!focus']\n ])\n\n # image + text\n s = t.style_create('STYLE')\n t.style_elements(s, ['elemSel', 'elemImg', 'elemTxt'])\n t.style_layout(s, 'elemImg', :expand=>:ns)\n t.style_layout(s, 'elemTxt', :squeeze=>:x, :expand=>:ns, :padx=>[2,0])\n t.style_layout(s, 'elemSel', :union=>['elemTxt'], :iexpand=>:ns, :ipadx=>2)\n\n @Priv[:edit, t] = ['elemTxt']\n @Priv[:sensitive, t] = [ [0, 'STYLE', 'elemImg', 'elemTxt'] ]\n @Priv[:dragimage, t] = [ [0, 'STYLE', 'elemImg', 'elemTxt'] ]\n\n t.notify_bind(t, 'Edit-accept',\n proc{|w, i, tt| w.item_text(i, 0, tt)}, '%T %I %t')\n\n dir_proc = proc{|file|\n item = t.item_create\n t.item_style_set(item, 0, 'STYLE')\n t.item_text(item, 0, File.basename(file))\n t.item_lastchild(:root, item)\n }\n\n file_proc = proc{|file|\n item = t.item_create\n t.item_style_set(item, 0, 'STYLE')\n\n ext = File.extname(file)\n case ext\n when '.dll'\n img = 'small-dll'\n when '.exe'\n img = 'small-exe'\n when '.txt'\n img = 'small-txt'\n else\n img = 'small-file'\n end\n\n type = ext.upcase\n type = type[1..-1] << ' ' unless type.empty?\n type << 'File'\n\n t.item_complex(item,\n [\n ['elemImg', {:image=>[@sel_images[img], ['selected'],\n @images[img], []]}],\n ['elemTxt', {:text=>File.basename(file)}]\n ])\n t.item_lastchild(:root, item)\n }\n\n demoExplorerAux(t, dir_proc, file_proc)\n\n t.activate(t.item_firstchild(:root))\n\n t.bindtags = [ t, 'TreeCtrlFileList', Tk::TreeCtrl, t.winfo_toplevel, :all ]\nend",
"def theatre\n theatre = Menu.new(\"What would you like to do with theatres?\")\n theatre.add_menu_item({key_user_returns: 1, user_message: \"Create a theatre.\", do_if_chosen: \"create/theatre\"})\n theatre.add_menu_item({key_user_returns: 2, user_message: \"Update a theatre.\", do_if_chosen: \"update/theatre\", parameters: [Location, \"theatre\"]})\n theatre.add_menu_item({key_user_returns: 3, user_message: \"Show me theatres.\", do_if_chosen: \"show/theatre\", parameters: [Location, \"theatre\"]})\n theatre.add_menu_item({key_user_returns: 4, user_message: \"Delete a theatre.\", do_if_chosen:\"delete/theatre\", parameters: [Location, \"theatre\"]})\n theatre.add_menu_item({key_user_returns: 5, user_message: \"Return to main menu.\", do_if_chosen: \"home\"})\n theatre\n end",
"def menu_relatorios\n relatorios_div.hover\n end",
"def TreeView_GetToolTips(hwnd) send_treeview_message(hwnd, :GETTOOLTIPS) end",
"def menu\n if self.has_parent?\n menu = self.parent.menu\n else\n menu = {:levels=>0,:items=>Array.new}\n end\n\n if !self.menu_items.empty?\n menu[:items][ menu[:levels] ] = self.menu_items\n menu[:levels] = menu[:levels]+1\n end\n\n return menu\n end",
"def menu\n @menu ||= Interface::Menu.new(self)\n end"
] |
[
"0.5552878",
"0.5515432",
"0.5512229",
"0.5428644",
"0.5341815",
"0.5265337",
"0.5244366",
"0.5115202",
"0.50719696",
"0.5021893",
"0.49993384",
"0.49921983",
"0.4962259",
"0.4944366",
"0.49434",
"0.49343783",
"0.493177",
"0.49247643",
"0.49219114",
"0.49016005",
"0.4888956",
"0.48768288",
"0.48448962",
"0.48448962",
"0.48400858",
"0.48268276",
"0.48156404",
"0.48149952",
"0.48146313",
"0.47902727",
"0.4789901",
"0.47895315",
"0.47873187",
"0.47859928",
"0.47833955",
"0.47607866",
"0.47589138",
"0.47589058",
"0.4758237",
"0.47487944",
"0.47417793",
"0.47401482",
"0.47245556",
"0.47146186",
"0.47138855",
"0.47103298",
"0.47094867",
"0.470876",
"0.47045553",
"0.47025436",
"0.46977687",
"0.46912563",
"0.4677754",
"0.4677199",
"0.4675592",
"0.46735963",
"0.46735382",
"0.46660778",
"0.46632355",
"0.4657391",
"0.46532288",
"0.46485853",
"0.4645027",
"0.4644581",
"0.46343005",
"0.46308365",
"0.46276748",
"0.4614915",
"0.46041593",
"0.46007052",
"0.45915383",
"0.45915383",
"0.4589297",
"0.45849207",
"0.458108",
"0.45799354",
"0.45780784",
"0.4575055",
"0.45714152",
"0.4567045",
"0.45658",
"0.45639396",
"0.4559139",
"0.4558875",
"0.45567855",
"0.4549511",
"0.45430255",
"0.45373723",
"0.45373568",
"0.45368716",
"0.45349732",
"0.45342162",
"0.45324597",
"0.45290545",
"0.45192665",
"0.45139414",
"0.45112163",
"0.45111477",
"0.45101476",
"0.45100686"
] |
0.53873336
|
4
|
Method to create call buttons
|
def makeCallButtons
callButtonId = 1
callButtonFloor = 1
for callButtonCounter in 1..@amountOfFloors
#If not first floor
if callButtonCounter > 1
callButton = CallButton.new(callButtonId, 'off', callButtonFloor, 'down')
@callButtonsList.push(callButton)
callButtonId += 1
end
#If not last floor
if callButtonCounter < @amountOfFloors
callButton = CallButton.new(callButtonId, 'off', callButtonFloor, 'up')
@callButtonsList.push(callButton)
callButtonId += 1
end
callButtonFloor += 1
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create_call_buttons\n \n for floor in 1..Elevator.num_floors do\n \n up_btn = CallButton.new(floor, \"up\", self)\n @up_call_buttons.append(up_btn)\n\n down_btn = CallButton.new(floor, \"down\", self)\n @down_call_buttons.append(down_btn)\n end\n end",
"def buttons; end",
"def how_to_create_buttons args\n # Define a button style\n args.state.button_style = { w: 82, h: 10, }\n\n # Render instructions\n args.state.button_message ||= \"Press a Button!\"\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: 42,\n y: 82,\n text: args.state.button_message,\n alignment_enum: 1)\n\n\n # Creates button one using a border and a label\n args.state.button_one_border = args.state.button_style.merge( x: 1, y: 32)\n args.nokia.borders << args.state.button_one_border\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: args.state.button_one_border.x + 2,\n y: args.state.button_one_border.y + NOKIA_FONT_SM_HEIGHT + 2,\n text: \"Button One\")\n\n # Creates button two using a border and a label\n args.state.button_two_border = args.state.button_style.merge( x: 1, y: 20)\n\n args.nokia.borders << args.state.button_two_border\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: args.state.button_two_border.x + 2,\n y: args.state.button_two_border.y + NOKIA_FONT_SM_HEIGHT + 2,\n text: \"Button Two\")\n\n # Initialize the state variable that tracks which button was clicked to \"\" (empty stringI\n args.state.last_button_clicked ||= \"--\"\n\n # If a click occurs, check to see if either button one, or button two was clicked\n # using the inside_rect? method of the mouse\n # set args.state.last_button_clicked accordingly\n if args.nokia.mouse_click\n if args.nokia.mouse_click.inside_rect? args.state.button_one_border\n args.state.last_button_clicked = \"One Clicked!\"\n elsif args.nokia.mouse_click.inside_rect? args.state.button_two_border\n args.state.last_button_clicked = \"Two Clicked!\"\n else\n args.state.last_button_clicked = \"--\"\n end\n end\n\n # Render the current value of args.state.last_button_clicked\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: 42,\n y: 5,\n text: args.state.last_button_clicked,\n alignment_enum: 1)\nend",
"def create_buttons\n @buttons = Array.new(@image_indexes.size) do |i|\n UI::PSDKMenuButton.new(@viewport, @image_indexes[i], i)\n end\n end",
"def add_buttons\n @p_button = Chingu::Rect.new(510,5,20,20)\n Chingu::Text.create(:text=>\"p\",:x=>513,:y=>5,:factor_x =>1.5)\n @m_button = Chingu::Rect.new(540,5,20,20)\n Chingu::Text.create(:text=>\"m\",:x=>540,:y=>5,:factor_x =>1.5)\n @o_button = Chingu::Rect.new(570,5,20,20)\n Chingu::Text.create(:text=>\"o\",:x=>575,:y=>5,:factor_x =>1.5)\n @save_button = Chingu::Rect.new(5,5,45,20)\n Chingu::Text.create(:text=>\"save\",:x=>5,:y=>5,:factor_x =>1.5)\n @load_button = Chingu::Rect.new(60,5,45,20)\n Chingu::Text.create(:text=>\"load\",:x=>65,:y=>5,:factor_x =>1.5)\n end",
"def add_call(text, command)\n button = Qt::PushButton.new(text)\n button.minimum_height = 50\n add_widget(button)\n connect(button, SIGNAL_CLICKED) { command.call }\n end",
"def button(&button_proc)\n @buttons << button_proc\n end",
"def create_buttons buttons, parent = nil\n\n buttons.each do |label, options|\n button = create_button(label)\n\n modifiers = options[:modifiers] || @accelerator_mods\n parent = options[:parent] || parent\n\n options[:keys].each do |key|\n\n key = Gdk::Keyval.from_name(key) if key.is_a? String\n\n button.add_accelerator(\n \"activate\", # event to call\n @accelerator_group, # accelerator group\n key, # Value of the key that will call this event\n modifiers, # any key modifiers (shift, ctrl, etc)\n @accelerator_flags # accelerator flags\n )\n end\n\n # if the parent exists, add this button to the parent\n parent.pack_start(button, true, true) unless !parent\n\n @buttons[label] = button\n end\n\n end",
"def form_buttons(**opt)\n opt.reverse_merge!('data-manifest': object.id)\n buttons = super\n buttons << submission_button(**opt)\n buttons << export_button(**opt)\n buttons << import_button(**opt)\n buttons << comm_status(**opt)\n block_given? ? yield(buttons) : buttons\n end",
"def buttons(&block)\n content = @template.capture(self, &block)\n @template.concat '<div class=\"buttons\">'\n @template.concat content\n @template.concat '</div>'\n end",
"def button_up(id); end",
"def create_extra_buttons()\n Rectangle.new(x:5,y:50,width:40,height:40,color:\"white\",z:1)\n Rectangle.new(x:16,y:66,width:18,height:9,color:\"#ff7eec\",z:1)\n Rectangle.new(x:5,y:100,width:40,height:40,color:\"white\",z:1)\n Rectangle.new(x:14,y:110,width:21,height:25,color:'#808080',z:1)\n Rectangle.new(x:14,y:110,width:21,height:5,color:'blue',z:1)\n Rectangle.new(x:5,y:150,width:40,height:40,color:\"white\",z:1)\n Triangle.new(x1:15,x2:35,x3:25,y1:180,y2:180,y3:160,color:\"black\",z:1)\n Rectangle.new(x:5,y:200,width:40,height:40,color:\"white\",z:1)\n Triangle.new(x1:15,x2:35,x3:25,y1:210,y2:210,y3:230,color:\"black\",z:1)\nend",
"def action_buttons\n button(class: 'btn icon-only btn-person btn-heart btn-group mr-2', type: \"button\") do\n i(class: 'ero-heart')\n end.on :click do\n AcceptWantToMeet.run(user_id: params.user.id).then do |response|\n GetRoomUserForContextAndJoin.run({ context_type: 'User', context_id: params.user.try(:id), user_id: params.user.try(:id) })\n .then do |room_user|\n ModalsService.open_modal('Messenger', { size_class: 'modal-lg messenger-modal', backdrop: 'static', initial_room_user_id: room_user.try(:id), is_paired: true })\n end.catch do |e|\n `toast.error('Nie udało się otworzyć czatu...')`\n end\n end.fail do |error|\n `toast.error(\"Ooops! Coś poszło nie tak.\")`\n end\n end\n button(class: 'btn icon-only btn-person btn-remove btn-group', type: \"button\") do\n i(class: 'ero-cross')\n end.on(:click) do |e|\n e.prevent_default\n e.stop_propagation\n remove_want_to_meet(params.user.id)\n end\n end",
"def createNewHypothesisButton()\n\t\treturn ButtonCreator.new(\n\t\t\t:assetName => 'plus.png', \n\t\t\t:assetSize => 40, \n\t\t\t:parent => self,\n\t\t\t:clicked => :btn_new_clicked\n\t\t)\n\tend",
"def add_the_button\n @theButton = UIButton.buttonWithType(UIButtonTypeRoundedRect)\n @theButton.setTitle('Refresh Weather!', forState:UIControlStateNormal)\n # @theButton.setTitleColor(BW.rgb_color(255, 255, 255), forState:UIControlStateNormal)\n @theButton.backgroundColor = BW.rgb_color(255, 255, 255)\n # @theButton.layer.borderColor = BW.rgb_color(255, 255, 255)\n # @theButton.layer.borderWidth = 0.5\n @theButton.layer.cornerRadius = 10\n @theButton.frame = [[center_h(200), (@view_height - 200)], [200,50]] #[[x-axis, y-axis], [width, height]]\n # @theButton.setTitle('Stop', forState:UIControlStateSelected)\n\n # Add an event for the button when touched\n # 'self' refers to the handler class for the action in which the callback is defined\n # buttonClicked is the method that will be called when the event happens\n # forControlEvents will take the event name\n @theButton.addTarget(self, action:'buttonClicked', forControlEvents:UIControlEventTouchUpInside)\n\n self.view.addSubview(@theButton)\n end",
"def create_action_buttons *labels\n @action_buttons = []\n _row = @height-3\n _col = (@width-(labels.count*8))/2\n _col = 5 if _col < 1\n\n labels.each_with_index do |l, ix|\n b = Button.new text: l, row: _row, col: _col\n _col += l.length+5\n @action_buttons << b\n @form.add_widget b\n b.command do\n @selected_index = ix\n throw(:close, ix)\n end\n end\n ## 2018-05-17 - associate RETURN ENTER key with first button (FIXME) should be Ok or Okay or user \n ## should have some say in this. Same for associating ESC with Cancel or Quit.\n @form.bind_key(10, \"Fire Ok button\") { @action_buttons.first.fire }\n end",
"def _button_4_command(*args)\n\n end",
"def createListTypeButtons\n @listTypeGroup = Qt::ButtonGroup.new\n allBtn = KDE::PushButton.new('All') do |w|\n w.objectName = 'switchButton'\n w.checkable = true\n w.autoExclusive = true\n connect(w, SIGNAL(:clicked), self, SLOT(:getList))\n end\n\n highlightsBtn = KDE::PushButton.new('Highlights') do |w|\n w.objectName = 'switchButton'\n w.setMinimumWidth(80)\n w.checkable = true\n w.autoExclusive = true\n connect(w, SIGNAL(:clicked), self, SLOT(:getList))\n end\n\n mostBtn = KDE::PushButton.new('Most Popular') do |w|\n w.objectName = 'switchButton'\n w.checkable = true\n w.autoExclusive = true\n connect(w, SIGNAL(:clicked), self, SLOT(:getList))\n end\n listTypeHLayout = Qt::HBoxLayout.new\n listTypeHLayout.addWidget(allBtn, 54) # 2nd parameter is stretch.\n listTypeHLayout.addWidget(highlightsBtn, 180)\n listTypeHLayout.addWidget(mostBtn,235)\n\n @listTypeGroup.addButton(allBtn, 0)\n @listTypeGroup.addButton(highlightsBtn, 1)\n @listTypeGroup.addButton(mostBtn, 2)\n @listTypeGroup.exclusive = true\n\n listTypeHLayout\n end",
"def button_up(id)\n\n end",
"def _button_2_command(*args)\n\n end",
"def _button_2_command(*args)\n\n end",
"def button_to(name, options = {}, html_options = {}) \n\t\thtml_options = check_options(html_options)\n\t\thtml_options[:class] << 'button'\n\t\tsuper(name, options, html_options)\n\tend",
"def button_up(id)\n end",
"def ribbon\n end",
"def createButtonsUpList\n for x in 1..(@numberOfFloors - 1) do\n @buttonsUpList.append(Button.new(x, ButtonStatus::OFF, x))\n # puts \"button up #{@buttonsUpList[x - 1].id} created\"\n end\n end",
"def fb_create_button(name, url)\n\t\t\t \t\"<fb:create-button href=\\\"#{url_for(url)}\\\">#{name}</fb:create-button>\"\n\t\t\tend",
"def fb_create_button(name, url)\n\t\t\t \t\"<fb:create-button href=\\\"#{url_for(url)}\\\">#{name}</fb:create-button>\"\n\t\t\tend",
"def create_floor_buttons\n for floor in 1..Elevator.num_floors do\n button = FloorButton.new(floor, self)\n @floor_buttons.append(button)\n end\n end",
"def update_call_menu\n end",
"def create_list\n @list = Array.new(6) { |i| DexButton.new(@viewport, i) }\n end",
"def _button_3_command(*args)\n\n end",
"def handling_method_buttons\n $tracer.trace(__method__)\n #unit_test_no_generate: handling_method_buttons, div.className(\"/hmethod/\"); GameStopCheckoutRadioButtons\n return GameStopCheckoutRadioButtons.new(ToolTag.new(div.className(\"/hmethod/\"), __method__, self), self)\n end",
"def create_bt_cmd(cmd_name, params, cb_btcmd)\r\n # get the cmd button ready to be used\r\n bt_cmd_created = get_next_btcmd()\r\n #p bt_cmd_created[:bt_wnd].methods\r\n #p bt_cmd_created[:bt_wnd].shown?\r\n bt_cmd_created[:name] = cmd_name\r\n bt_cmd_created[:bt_wnd].show\r\n #p bt_cmd_created[:bt_wnd].shown?\r\n bt_cmd_created[:bt_wnd].text = cmd_name.to_s\r\n bt_cmd_created[:bt_wnd].enable\r\n bt_cmd_created[:bt_wnd].connect(SEL_COMMAND) do\r\n bt_cmd_created[:bt_wnd].disable\r\n send(cb_btcmd, params)\r\n end\r\n \r\n # send canvas size changed\r\n @app_owner.activate_canvas_frame\r\n end",
"def show_button_template\n UI::FBButtonTemplate.new(SampleElements::BUTTON_TEMPLATE_TEXT,\n SampleElements::BUTTON_TEMPLATE_BUTTONS)\n .send(@user)\n end",
"def generateButtons\n @moves = @battler.moves\n @nummoves = 0\n @oldindex = -1\n @x = []; @y = []\n for i in 0...4\n @button[\"#{i}\"].dispose if @button[\"#{i}\"]\n @nummoves += 1 if @moves[i] && @moves[i].id\n @x.push(@viewport.width/2 + (i%2==0 ? -1 : 1)*(@viewport.width/2 + 99))\n @y.push(@viewport.height - 90 + (i/2)*44)\n end\n for i in 0...4\n @y[i] += 22 if @nummoves < 3\n end\n @button = {}\n for i in 0...@nummoves\n # get numeric values of required variables\n movedata = GameData::Move.get(@moves[i].id)\n category = movedata.physical? ? 0 : (movedata.special? ? 1 : 2)\n type = GameData::Type.get(movedata.type).id_number\n # create sprite\n @button[\"#{i}\"] = Sprite.new(@viewport)\n @button[\"#{i}\"].param = category\n @button[\"#{i}\"].z = 102\n @button[\"#{i}\"].bitmap = Bitmap.new(198*2, 74)\n @button[\"#{i}\"].bitmap.blt(0, 0, @buttonBitmap, Rect.new(0, type*74, 198, 74))\n @button[\"#{i}\"].bitmap.blt(198, 0, @buttonBitmap, Rect.new(198, type*74, 198, 74))\n @button[\"#{i}\"].bitmap.blt(65, 46, @catBitmap, Rect.new(0, category*22, 38, 22))\n @button[\"#{i}\"].bitmap.blt(3, 46, @typeBitmap, Rect.new(0, type*22, 72, 22))\n baseColor = @buttonBitmap.get_pixel(5, 32 + (type*74)).darken(0.4)\n pbSetSmallFont(@button[\"#{i}\"].bitmap)\n pbDrawOutlineText(@button[\"#{i}\"].bitmap, 198, 10, 196, 42,\"#{movedata.real_name}\", Color.white, baseColor, 1)\n pp = \"#{@moves[i].pp}/#{movedata.total_pp}\"\n pbDrawOutlineText(@button[\"#{i}\"].bitmap, 0, 48, 191, 26, pp, Color.white, baseColor, 2)\n pbSetSystemFont(@button[\"#{i}\"].bitmap)\n text = [[movedata.real_name, 99, 4, 2, baseColor, Color.new(0, 0, 0, 24)]]\n pbDrawTextPositions(@button[\"#{i}\"].bitmap, text)\n @button[\"#{i}\"].src_rect.set(198, 0, 198, 74)\n @button[\"#{i}\"].ox = @button[\"#{i}\"].src_rect.width/2\n @button[\"#{i}\"].x = @x[i]\n @button[\"#{i}\"].y = @y[i]\n end\n end",
"def render\n _button.btn.btn_primary request, onClick: self.click, disabled: @disabled\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n\n params[:display] = @display if [\"instances\"].include?(@display) # Were we displaying vms/hosts/storages\n params[:page] = @current_page if @current_page.nil? # Save current page for list refresh\n\n if params[:pressed] == \"custom_button\"\n custom_buttons\n return\n end\n\n if params[:pressed].starts_with?(\"instance_\") # Handle buttons from sub-items screen\n pfx = pfx_for_vm_button_pressed(params[:pressed])\n process_vm_buttons(pfx)\n\n # Control transferred to another screen, so return\n return if [\"#{pfx}_policy_sim\", \"#{pfx}_compare\", \"#{pfx}_tag\",\n \"#{pfx}_retire\", \"#{pfx}_protect\", \"#{pfx}_ownership\",\n \"#{pfx}_refresh\", \"#{pfx}_right_size\",\n \"#{pfx}_reconfigure\"].include?(params[:pressed]) &&\n @flash_array.nil?\n\n unless [\"#{pfx}_edit\", \"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n @refresh_div = \"main_div\"\n @refresh_partial = \"layouts/gtl\"\n show # Handle VMs buttons\n end\n elsif params[:pressed] == \"make_ot_orderable\"\n make_ot_orderable\n return\n elsif params[:pressed] == \"orchestration_template_copy\"\n orchestration_template_copy\n return\n elsif params[:pressed] == \"orchestration_templates_view\"\n orchestration_templates_view\n return\n else\n params[:page] = @current_page if @current_page.nil? # Save current page for list refresh\n @refresh_div = \"main_div\" # Default div for button.rjs to refresh\n case params[:pressed]\n when \"orchestration_stack_delete\"\n orchestration_stack_delete\n when \"orchestration_stack_retire\"\n orchestration_stack_retire\n when \"orchestration_stack_retire_now\"\n orchestration_stack_retire_now\n return\n when \"orchestration_stack_tag\"\n tag(OrchestrationStack)\n when params[:pressed] == \"custom_button\"\n custom_buttons\n return\n end\n return if %w[orchestration_stack_retire orchestration_stack_tag].include?(params[:pressed]) &&\n @flash_array.nil? # Tag screen showing, so return\n end\n\n check_if_button_is_implemented\n\n if single_delete_test\n single_delete_redirect\n elsif params[:pressed].ends_with?(\"_edit\") || [\"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n render_or_redirect_partial(pfx)\n elsif @refresh_div == \"main_div\" && @lastaction == \"show_list\"\n replace_gtl_main_div\n else\n render_flash unless performed?\n end\n end",
"def createHypothesisButtons(hypothesis)\n\t\tcss = self.btnCSS(hypothesis)\n\t\taccept = ButtonCreator.new(:assetName => 'check.png', :assetSize => 40, :css => css)\n\t\treject = ButtonCreator.new(:assetName => 'close.png', :assetSize => 40, :css => css)\n\n\t\taccept.signal_connect('clicked') { self.btn_accept_clicked(hypothesis) }\n\t\treject.signal_connect('clicked') { self.btn_reject_clicked(hypothesis) }\n\n\t\treturn GridCreator.fromArray([accept, reject], :vertical => true)\n\tend",
"def add_button_clicked\n\t\t\n\t\t\t# Eventually create browse form\n\t\t\tcreate_browse_form\n\t\t\n\t\t\t# Show and activate the child window\n\t\t\tshow_browse_form\n\t\tend",
"def multi_buttons\n box = JPanel.new\n\n new_button = JButton.new('New')\n new_button.add_action_listener do |e| \n @combo.editable = true\n @combo.editor.select_all\n @last_button_text = 'New'\n end\n box.add(new_button)\n\n copy_button = JButton.new('Copy')\n copy_button.add_action_listener do |e| \n copy = \"Copy of #{@combo.selected_item}\"\n @dialog_defaults[copy] = @dialog_defaults[@combo.selected_item].dup\n @combo.add_item(copy)\n @combo.selected_item = copy\n @combo.editable = true\n @combo.editor.select_all\n @last_button_text = 'Copy'\n end\n box.add(copy_button)\n\n delete_set = JButton.new('Delete')\n delete_set.add_action_listener {|e| delete_current_set}\n box.add(delete_set)\n box\n end",
"def generate_buttons(buttons:)\n fb_buttons = buttons.collect do |button|\n case button['type']\n when 'url'\n _button = {\n \"type\" => \"web_url\",\n \"url\" => button[\"url\"],\n \"title\" => button[\"text\"]\n }\n\n if button[\"webview_height\"].present?\n _button[\"webview_height_ratio\"] = button[\"webview_height\"]\n end\n\n if button['messenger_extensions'].present?\n _button['messenger_extensions'] = true\n end\n\n _button\n\n when 'payload'\n _button = {\n \"type\" => \"postback\",\n \"payload\" => button[\"payload\"],\n \"title\" => button[\"text\"]\n }\n\n when 'call'\n _button = {\n \"type\" => \"phone_number\",\n \"payload\" => button[\"phone_number\"],\n \"title\" => button[\"text\"]\n }\n\n when 'login'\n _button = {\n \"type\" => \"account_link\",\n \"url\" => button[\"url\"]\n }\n\n when 'logout'\n _button = {\n \"type\" => \"account_unlink\"\n }\n\n when 'nested'\n _button = {\n \"type\" => \"nested\",\n \"title\" => button[\"text\"],\n \"call_to_actions\" => generate_buttons(buttons: button[\"buttons\"])\n }\n\n else\n raise(Stealth::Errors::ServiceImpaired, \"Sorry, we don't yet support #{button[\"type\"]} buttons yet!\")\n end\n\n _button\n end\n\n fb_buttons\n end",
"def createButtonsDownList\n for x in 2..@numberOfFloors do\n @buttonsDownList.append(Button.new(x, ButtonStatus::OFF, x))\n # puts \"button down #{@buttonsDownList[x - 2].id} created\"\n end\n end",
"def create_line_item_button\n self.get_element(@browser, 'create')\n end",
"def bp_buttons(*args, &block)\n if block_given?\n options = args.first || {}\n html_options = args.second\n bp_buttons(capture(&block), options, html_options)\n else\n html_buttons = args.first\n options = args.second || {}\n options_hash = options\n\n options_hash[:class] = options[:class].blank? ? 'bp-box-buttons' : bp_class(\"bp-box-buttons #{options[:class]}\")\n label = options[:label].blank? ? '' : content_tag(:div, bp_html_print(options[:label]), :class=>'label')\n\n out = label\n out += html_buttons\n\n content_tag :div, bp_html_print(out), options_hash\n end\n end",
"def b(*args)\n JButton.new *args\n end",
"def update_cc_button\n\t\t$tracer.trace(__method__)\n return ToolTag.new(input.className(create_ats_regex_string(\"ats-updtccbtn\")), __method__)\n\tend",
"def button\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n @refresh_div = \"main_div\" # Default div for button.rjs to refresh\n\n case params[:pressed]\n when 'miq_request_delete' then deleterequests\n when 'miq_request_edit' then request_edit\n when 'miq_request_copy' then request_copy\n when 'miq_request_reload' then handle_request_reload\n else javascript_flash(:text => _('Button not yet implemented'), :severity => :error)\n end\n end",
"def create_color_buttons()\n Rectangle.new(x:5,y:450,width:45,height:45,color:'red',z:1)\n Rectangle.new(x:55,y:450,width:45,height:45,color:'orange',z:1)\n Rectangle.new(x:105,y:450,width:45,height:45,color:'yellow',z:1)\n Rectangle.new(x:155,y:450,width:45,height:45,color:'green',z:1)\n Rectangle.new(x:205,y:450,width:45,height:45,color:'blue',z:1)\n Rectangle.new(x:255,y:450,width:45,height:45,color:'#EE82EE',z:1)\n Rectangle.new(x:305,y:450,width:45,height:45,color:'black',z:1)\n Rectangle.new(x:355,y:450,width:45,height:45,color:'#808080',z:1)\n Rectangle.new(x:405,y:450,width:45,height:45,color:'white',z:1)\nend",
"def on_click\n\t\tend",
"def push_button(floor)\n\t\t@buttons[floor] = true\n\tend",
"def create_texts\n self.title = I18n.t(:tictactoe)\n @new_btn.label = I18n.t(:new_game)\n @quit_btn.label = I18n.t(:quit)\n @default_size_btn.label = I18n.t(:default_size)\n end",
"def build_toolbar_button(url_hash)\n url_hash[:empty_selection] ||= url_hash[:single]\n url_hash[:build_callback] ||= :selection unless url_hash[:empty_selection]\n classes = ['grid_toolbar_item', 'button', 'ui-state-default', 'ui-corner-all']\n s = <<-EOS\njQuery('<div class=\"#{(classes + Array(url_hash[:class])).compact.join(' ')}\" />')\n .text('#{escape_javascript(url_hash[:name])}')\n .button()\n .click(\n #{hash_to_callback(url_hash)}\n ).appendTo('#t_' + #{format_type_to_js(@table_id)});\nEOS\n end",
"def handling_method_buttons\n $tracer.trace(format_method(__method__))\n return GameStopHandlingMethodRadioButtons.new(ToolTag.new(@tag.find.div.className(\"/hmethod/\"), format_method(__method__)))\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n params[:display] = @display if %w(vms instances images).include?(@display)\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n return tag(\"CloudTenant\") if params[:pressed] == 'cloud_tenant_tag'\n if params[:pressed].starts_with?(\"vm_\", # Handle buttons from sub-items screen\n \"miq_template_\",\n \"guest_\",\n \"image_\",\n \"instance_\")\n\n pfx = pfx_for_vm_button_pressed(params[:pressed])\n process_vm_buttons(pfx)\n return if [\"#{pfx}_policy_sim\", \"#{pfx}_compare\", \"#{pfx}_tag\", \"#{pfx}_retire\",\n \"#{pfx}_protect\", \"#{pfx}_ownership\", \"#{pfx}_refresh\", \"#{pfx}_right_size\",\n \"#{pfx}_reconfigure\"].include?(params[:pressed]) &&\n @flash_array.nil?\n\n unless [\"#{pfx}_edit\", \"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n @refresh_div = \"main_div\"\n @refresh_partial = \"layouts/gtl\"\n show\n end\n elsif params[:pressed] == \"custom_button\"\n custom_buttons\n # custom button screen, so return, let custom_buttons method handle everything\n return\n end\n render_button_partial(pfx)\n end",
"def render_button\n NfgUi::Components::Elements::Button.new({ **integrated_slat_action_button_component_options, body: (block_given? ? yield : body) }, view_context).render\n end",
"def mgs_buy_as_guest_btn\n\t\t$tracer.trace(__method__)\n\t\treturn ToolTag.new(button.className(create_ats_regex_string(\"ats-buyasguest\")), __method__)\n\tend",
"def all_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(@menu_tag.find.div.className(\"mm-content-base\").find.a.className(\"mainButton\"), format_method(__method__))\n end",
"def makeFloorRequestButton\n floorRequestButtonFloor = 1\n for i in 1..@amountOfFloors\n floorRequestButton = FloorRequestButton.new(i, 'off', floorRequestButtonFloor)\n @floorRequestButtonsList.push(floorRequestButton)\n floorRequestButtonFloor += 1\n end\n end",
"def btn_area_first\n\n\t\t@layer_btns = HBox.new( true, 0 )\n\t\t@layer_btns.set_size_request( 800 , 40 )\n\n\t\t@btn_sintrom = Button.new(\"Sintrom\")\n\t\t@btn_sintrom.set_size_request( 100, 40 )\n\t\t@btn_sintrom.signal_connect( \"clicked\" ) do\n\t\t\tmain_area_sintrom\n\t\tend\n\t\t@btn_agenda = Button.new(\"Agenda\")\n\t\t@btn_agenda.set_size_request( 100, 40 )\n\t\t@btn_agenda.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\t\t@btn_bdays = Button.new(\"Cumpleaños\")\n\t\t@btn_bdays.set_size_request( 100, 40 )\n\t\t@btn_bdays.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\t\t@btn_shifts = Button.new(\"Turnos\")\n\t\t@btn_shifts.set_size_request( 100, 40 )\n\t\t@btn_shifts.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\t\t@btn_exit = Button.new(\"Exit\")\n\t\t@btn_exit.set_size_request( 100, 40 )\n\t\t@btn_exit.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\n\t\t@layer_btns.add( @btn_sintrom )\n\t\t@layer_btns.add( @btn_agenda )\n\t\t@layer_btns.add( @btn_bdays )\n\t\t@layer_btns.add( @btn_shifts )\n\t\t@layer_btns.add( @btn_exit )\n\n\t\t@layer_general.put( @layer_btns, 0, 760 )\n\n\tend",
"def mgs_buy_as_new_account_btn\n\t\t$tracer.trace(__method__)\n\t\treturn ToolTag.new(button.className(create_ats_regex_string(\"ats-buyasnew\")), __method__)\n\tend",
"def create_actions\n app = self\n\n # Help > About box\n @about_action = Qt::Action.new(tr(\"&About...\"), self) do\n self.status_tip = tr(\"Show information about the application.\")\n connect(SIGNAL(:triggered)) do\n Qt::MessageBox.about(nil,\n tr(\"About the Wallet\"),\n tr(\"Visit <a href='http://opencoinage.org/'>OpenCoinage.org</a> for more information.\"))\n end\n end\n\n # Currency > Import file dialog\n @import_file_action = Qt::Action.new(tr(\"Import from &File...\"), self) do\n self.status_tip = tr(\"Import a currency contract from a file.\")\n connect(SIGNAL(:triggered)) do\n if file = app.open_file_dialog(caption = tr(\"Import Currency\"))\n app.not_implemented_yet(caption) # TODO\n end\n end\n end\n\n # Currency > Import URL dialog\n @import_url_action = Qt::Action.new(tr(\"Import from &URL...\"), self) do\n self.status_tip = tr(\"Import a currency contract from a URL.\")\n connect(SIGNAL(:triggered)) do\n if url = app.get_text(caption = tr(\"Import Currency\"), tr(\"Enter a currency URL:\"), :text => \"http://\")\n app.not_implemented_yet(caption) # TODO\n end\n end\n end\n\n # Token > Verify dialog\n @verify_action = Qt::Action.new(tr(\"&Verify...\"), self) do\n self.status_tip = tr(\"Verify the selected tokens with the issuer.\")\n connect(SIGNAL(:triggered)) do\n app.not_implemented_yet(caption = tr(\"Verifying Tokens\")) # TODO: progress dialog\n end\n end\n\n # Token > Reissue dialog\n @reissue_action = Qt::Action.new(tr(\"&Reissue...\"), self) do\n self.status_tip = tr(\"Reissue the selected tokens with the issuer.\")\n connect(SIGNAL(:triggered)) do\n app.not_implemented_yet(caption = tr(\"Reissuing Tokens\")) # TODO: progress dialog\n end\n end\n end",
"def add_button_to_query(button); end",
"def linkwizard_startover_button\n $tracer.trace(__method__)\n return ToolTag.new(form.id(\"StartOver\").button.className(\"/btn/\") ,__method__)\n end",
"def gentest; catdet.button(:name, 'testEvent'); end",
"def create_start_button(x, y)\n\t\tbutton = Button.new(@window, \n\t\t\t\t\t\t\t@window.user_messages.message(:start), \n\t\t\t\t\t\t\tConstants::BT_TEXT_HEIGHT,\n\t\t\t\t\t\t\tConstants::FONT_NAME)\n\n\t\tbutton.add_callback(:release, lambda do\n\t\t\treturn if !ready_to_start?\n\n\t\t\tplayers = entries_to_players\n\t\t\tfactory = GameFactory.new(GameControllerFactory.new)\n\t\t\tgame_over = create_game_over_callable\n\t\t\t@window.state = factory.create_game(@window, game_over, *players)\n\t\tend)\n\n\t\tbutton.x = x\n\t\tbutton.y = y\n\t\tbutton\n\tend",
"def render_buttons(doc, object)\n pid = doc['id']\n apo_pid = doc.apo_pid\n\n buttons = []\n if can?(:manage_content, object)\n buttons << {\n url: close_version_ui_item_path(pid),\n label: 'Close Version',\n check_url: workflow_service_closeable_path(pid)\n }\n\n buttons << {\n url: open_version_ui_item_path(pid),\n label: 'Open for modification',\n check_url: workflow_service_openable_path(pid)\n }\n end\n\n if can?(:manage_item, object)\n if object.is_a? Dor::AdminPolicyObject\n buttons << { url: edit_apo_path(pid), label: 'Edit APO', new_page: true }\n buttons << { url: new_apo_collection_path(apo_id: pid), label: 'Create Collection' }\n end\n\n buttons << {\n url: dor_reindex_path(pid: pid),\n label: 'Reindex',\n new_page: true\n }\n\n # note that the backend will also check can?(:manage_governing_apo, object, new_apo_id), but\n # we can't do that here, since we don't yet know what APO the user might move the object to.\n # so it's possible that the user will get this button even if there are no other APOs they're\n # allowed to move the object to.\n buttons << {\n url: set_governing_apo_ui_item_path(id: pid),\n label: 'Set governing APO',\n disabled: !object.allows_modification?\n }\n\n buttons << { url: new_item_workflow_path(item_id: pid), label: 'Add workflow' }\n\n buttons << {\n url: dor_path(pid: pid),\n label: 'Republish',\n check_url: workflow_service_published_path(pid),\n new_page: true\n }\n\n buttons << {\n url: purge_item_path(id: pid),\n label: 'Purge',\n new_page: true,\n confirm: 'This object will be permanently purged from DOR. This action cannot be undone. Are you sure?',\n disabled: !registered_only?(doc)\n }\n\n buttons << { url: source_id_ui_item_path(id: pid), label: 'Change source id' }\n buttons << { url: tags_ui_item_path(id: pid), label: 'Edit tags' }\n if [Dor::Item, Dor::Set].any? { |clazz| object.is_a? clazz } # these only apply for items, sets and collections\n buttons << { url: catkey_ui_item_path(id: pid), label: 'Manage catkey' }\n buttons << { url: collection_ui_item_path(id: pid), label: 'Edit collections' }\n end\n if object.datastreams.include? 'contentMetadata'\n buttons << { url: item_content_type_path(item_id: pid), label: 'Set content type' }\n end\n if object.datastreams.include? 'rightsMetadata'\n buttons << { url: rights_item_path(id: pid), label: 'Set rights' }\n end\n if object.datastreams.include?('identityMetadata') && object.identityMetadata.otherId('catkey').present? # indicates there's a symphony record\n buttons << { url: refresh_metadata_item_path(id: pid), label: 'Refresh descMetadata', new_page: true, disabled: !object.allows_modification? }\n end\n buttons << { url: manage_release_solr_document_path(pid), label: 'Manage release' }\n\n # TODO: add a date picker and button to change the embargo date for those who should be able to.\n buttons << { label: 'Update embargo', url: embargo_form_item_path(pid) } if object.is_a?(Dor::Item) && object.embargoed?\n\n end\n\n buttons\n end",
"def button_actions\n return @button_actions if @button_actions\n\n @button_actions = [proc {}]\n\n @button_actions << proc do\n @units = swap_units(@units || 'imperial')\n end\n\n @button_actions << proc do\n @disp = @disp == :temp ? :desc : :temp\n end\n\n @button_actions << proc do\n raise IndexError, 'Cancel button was pressed'\n end\n end",
"def button(found, date_id, new_date)\n ret_btn = \"<a href='#{button_href(date_id)}' \"\n ret_btn += \"class='#{button_classes(found)}'>\"\n ret_btn += \"#{button_text(found, new_date)}</a>\"\n ret_btn\n end",
"def create_command_window\n end",
"def clicked;end",
"def question_classic_button_click\n MenuControllerContracts.invariant(self)\n @alert_view = @help_view = Views::ConnectInstructionsAlertView.new(@window, self)\n MenuControllerContracts.invariant(self)\n end",
"def button_tech_demo\n x, y, w, h = 460, 160, 300, 50\n state.button ||= state.new_entity(:button_with_fade)\n\n # Adds w.half to x and h.half + 10 to y in order to display the text inside the button's borders.\n state.button.label ||= [x + w.half, y + h.half + 10, \"click me and watch me fade\", 0, 1]\n state.button.border ||= [x, y, w, h]\n\n if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.button.border) # if mouse is clicked, and clicked inside button's border\n state.button.clicked_at = inputs.mouse.click.created_at # stores the time the click occurred\n end\n\n outputs.labels << state.button.label\n outputs.borders << state.button.border\n\n if state.button.clicked_at # if button was clicked (variable has a value and is not nil)\n\n # The appearance of the button changes for 0.25 seconds after the time the button is clicked at.\n # The color changes (rgb is set to 0, 180, 80) and the transparency gradually changes.\n # Change 0.25 to 1.25 and notice that the transparency takes longer to return to normal.\n outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.button.clicked_at.ease(0.25.seconds, :flip)]\n end\n end",
"def _recreate_buttons\n $log.debug \" inside recreate_buttons: #{@tabs.size} \"\n r = @row\n col = @col + 1\n @buttons ||= []\n if !@buttons.empty?\n @buttons.each {|e| @form.remove_widget(e) }\n end\n @buttons = []\n button_gap = 4\n # the next line necessitates a clear on the pad\n # button_gap = 1 if @tabs.size > 6 # quick dirty fix, we need something that checks fit\n # we may also need to truncate text to fit\n\n @buttonpad.wclear\n ## create a button for each tab\n $tabradio = Variable.new # so we know which is highlighted\n @tabs.each do |tab|\n text = tab.text\n $log.debug \" TABS EACH #{text} \"\n @buttons << RubyCurses::TabbedButton.new(@form) do\n variable $tabradio\n text text\n name text\n value text\n row r + 1\n col col\n end\n col += text.length + button_gap\n # if col exceeds pad_w then we need to expand pad\n # but here we don't know that a pad is being used\n $log.debug \" button col #{col} \" \n form = tab.form\n form.set_parent_buffer(@window) if form\n\n b = @buttons.last\n b.command(b) { \n $log.debug \" calling display form from button press #{b.name} #{b.state} \"\n # form.rep essentially sees that buttons get correct attributes\n # when triggering M-<char>. This button should get highlighted.\n tab.repaint\n button_form_repaint #( b.state == :HIGHLIGHTED )\n if @display_tab_on_traversal\n # set as old tab so ONLY on going down this becomes current_tab\n @old_tab = tab\n else\n # next line means next key is IMMED taken by the tab not main form\n @current_tab = tab\n end\n fire_event tab, tab.index, :OPEN\n }\n end\n @recreate_buttons = false\n # make the buttons visible now, not after next handle_key\n @form.repaint\n end",
"def click; end",
"def click; end",
"def click; end",
"def create_button_config( action_title_i19n_sym, action_title_i19n_scope_sym, image_name = \"cog.png\" )\n action_text = I18n.t( action_title_i19n_sym.to_sym, {:scope => [action_title_i19n_scope_sym ? action_title_i19n_scope_sym.to_sym : nil]} )\n tooltip_text = I18n.t( \"#{action_title_i19n_sym}_tooltip\".to_sym, {:scope => [action_title_i19n_scope_sym ? action_title_i19n_scope_sym.to_sym : nil]} )\n {\n :xtype => 'button',\n :id => action_title_i19n_sym.to_s,\n :name => action_title_i19n_sym.to_s,\n :icon => \"/images/icons/#{ image_name }\",\n :text => \"#{ action_text }\",\n :tooltip => \"#{ tooltip_text }\",\n :margin => '0 3 3 3'\n }\n end",
"def initialize(args={})\n super\n @widget = args[:widget]\n @title = args[:title] || \"\"\n @buttons = [args[:buttons]].flatten.compact\n\n @buttons = [\"OK\", \"Cancel\"] if @buttons.empty?\n end",
"def dialog_button_operation(method, display_name)\n dialogs = []\n\n # Either a list or coming from a different controller (eg from host screen, go to its vms)\n if !params[:id]\n dialogs = find_checked_items\n if dialogs.empty?\n add_flash(_(\"No Dialogs were selected for %{task}\") % {:task => display_name}, :error)\n else\n process_dialogs(dialogs, method)\n end\n get_node_info\n replace_right_cell(:nodetype => x_node, :replace_trees => [:dialogs])\n elsif params[:id].nil? || !Dialog.exists?(:id => params[:id])\n add_flash(_(\"Dialog no longer exists\"), :error)\n dialog_list\n @refresh_partial = \"layouts/gtl\"\n else\n dialogs.push(params[:id])\n process_dialogs(dialogs, method) unless dialogs.empty?\n # TODO: tells callers to go back to show_list because this record may be gone\n # Should be refactored into calling show_list right here\n if method == 'destroy'\n self.x_node = \"root\"\n end\n get_node_info\n replace_right_cell(:nodetype => x_node, :replace_trees => [:dialogs])\n end\n dialogs.count\n end",
"def button_up(id)\n super(id)\n @buttons_up << id unless @buttons_up.include?(id)\n end",
"def call_links()\n\t\treturn $test_driver.find_elements(:link_text, \"call\")\n\tend",
"def build\n @buttons = Hash.new\n create_palettes\n end",
"def handling_method_buttons\n $tracer.trace(__method__)\n # unit_test_no_generate: handling_method_buttons, input.className(create_ats_regex_string(\"ats-wis-shippingoptions\")).parent(\"div\").at(1); WebInStoreRadioButtons\n return WebInStoreRadioButtons.new(ToolTag.new(input.className(create_ats_regex_string(\"ats-wis-shippingoptions\")).parent(\"div\").at(1), __method__, self), self)\n end",
"def button_to_remote name, css_class, options = {}\n button_to_function name, remote_function(options), :class=>css_class\n end",
"def call\n self.class.instance_methods(false).each do |method|\n @commands = []\n @title = method\n send(method)\n create_tab\n end\n end",
"def button_tag( title, url_hash, image=\"\", image_in_own_line=true, popup=false, class_name=\"\" )\n url = popup ? \"popWindow(\\\"#{url_for url_hash}\\\")\" : \"navigateTo(\\\"#{url_for url_hash}\\\")\";\n button_function_tag( title, url, image, image_in_own_line, class_name );\n end",
"def button_down id\n end",
"def button_to( url, text = url, opts = {} )\n tag :button, text, opts.merge( url: url )\nend",
"def buttons(*args, &block)\n html_options = args.extract_options!\n html_options[:class] ||= \"buttons\"\n\n if block_given?\n field_set_and_list_wrapping(html_options, &block)\n else\n args = [:commit] if args.empty?\n contents = args.map { |button_name| send(:\"#{button_name}_button\") }\n field_set_and_list_wrapping(html_options, contents)\n end\n end",
"def create\n @button = Button.new(button_params)\n @button.family_id = @current_user.family_id\n\n respond_to do |format|\n if params[:commit] == \"作成する\"\n if @button.save\n format.html { redirect_to buttons_path, notice: 'ボタンを作成しました' }\n else\n format.html { render :new }\n end\n else params[:create_item] == \"作成 & 買い物リストに追加する\"\n if create_button_with_item\n format.html { redirect_to buttons_path, notice: \"#{@button.name}を買い物リストに追加しました\"}\n else\n format.html { render :new }\n end\n end\n end\n end",
"def radio_button(object_name, method, tag_value, options = T.unsafe(nil)); end",
"def create_texts\n self.title = I18n.t(:options)\n @new_btn.label = I18n.t(:begin)\n @quit_btn.label = I18n.t(:quit)\n @idiom_rdo[0].label = I18n.t(:english)\n @idiom_rdo[1].label = I18n.t(:portuguese)\n @idiom_rdo[2].label = I18n.t(:spanish)\n @mode_rdo[0].label = I18n.t(:player_player)\n @mode_rdo[1].label = I18n.t(:player_very_easy)\n @mode_rdo[2].label = I18n.t(:player_easy)\n @mode_rdo[3].label = I18n.t(:player_medium)\n @mode_rdo[4].label = I18n.t(:player_impossible) \n end",
"def new_button\n begin\n $results.log_action(\"button(#{@params[0..-1].join(' ')})\")\n if @params[1].nil?\n @driver.find_element(:link_text, 'New').click\n else\n # If the New Button has multiple options, choose the right one from the dropdown menu.\n buttons = @driver.find_elements(:class, 'caret')\n buttons[2].click\n @driver.find_element(:link_text, @params[1].capitalize).click\n end\n $session.wait_for_stale\n $results.success\n rescue => ex\n $results.fail(\"button(#{@params.join(' ')})\", ex)\n end\n end",
"def rounded_button_function(name, function, html_options = {}, &block)\n (html_options[:class] ||= \"\") << \" button\"\n if icon = html_options.delete(:icon)\n link_to_function(content_tag(:span, name, :class => \"icon #{icon}\"), function, html_options, &block)\n else\n link_to_function(name, function, html_options, &block)\n end\n end",
"def message_button(name)\n library_li(name).button(:class=>/sakai_sendmessage_overlay/)\n end",
"def create_button value\n\n button = Gtk::Button.new(value)\n\n # handle keyboard input, which uses \"active\" event on button\n button.signal_connect(\"activate\") do |widget|\n handle_input widget.label\n end\n\n # handle mouse-click event, which uses \"pressed\" event\n button.signal_connect(\"pressed\") do |widget|\n handle_input widget.label\n end\n\n button.set_can_focus false\n\n button\n\n end",
"def viewDidLoad\n super\n\n self.title = 'ButtonsTitle'.localized\n\n @data_source_array = [\n {\n :title => 'UIButton',\n :label => 'Background Image'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef gray_button\",\n :view => self.gray_button\n },\n {\n :title => 'UIButton',\n :label => 'Button with Image'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef image_button\",\n :view => self.image_button\n },\n {\n :title => 'UIButtonTypeRoundedRect',\n :label => 'Rounded Button'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef rounded_button_type\",\n :view => self.rounded_button_type\n },\n {\n :title => 'UIButtonTypeRoundedRect',\n :label => 'Attributed Text'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef attr_text_button\",\n :view => self.attr_text_button\n },\n {\n :title => 'UIButtonTypeDetailDisclosure',\n :label => 'Detail Disclosure'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef detail_disclosure_button\",\n :view => self.detail_disclosure_button\n },\n {\n :title => 'UIButtonTypeInfoLight',\n :label => 'Info Light'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef info_light_button_type\",\n :view => self.info_light_button_type\n },\n {\n :title => 'UIButtonTypeInfoDark',\n :label => 'Info Dark'.localized,\n :source => \"rc_buttons_view_controller.rb:\\rdef info_dark_button_type\",\n :view => self.info_dark_button_type\n },\n {\n :title => 'UIButtonTypeContactAdd',\n :label => 'Contact Add',\n :source => \"rc_buttons_view_controller.rb:\\rdef contact_add_button_type\",\n :view => self.contact_add_button_type\n }\n ]\n\n self.tableView.registerClass( UITableViewCell, forCellReuseIdentifier: DISPLAY_CELL_ID )\n self.tableView.registerClass( UITableViewCell, forCellReuseIdentifier: SOURCE_CELL_ID )\n end",
"def mag_button_to_remote_selected(name, options = {}, html_options = {}) \n html_options[:class] = add_default_styling_selected(html_options[:class])\n name.gsub!(/\\s/, \" \")\n link_to_function(\"<span>#{name}</span>\", remote_function(options), html_options)\n end",
"def on_button(b, evnt, coords)\n #puts \"B#{b} #{evnt}, #{coords}\"\n end",
"def command_btn(title:, key:, display:, help: nil, color: \"default\")\n button_tag(title,\n class: \"btn btn-#{color} btn-block\",\n title: help,\n id: \"#{key.to_s.downcase}_btn\",\n data: {\n toggle: \"cli\",\n target: cli_product_path(key, name: @product.name, type: @type),\n title: title,\n cmd: \"<code>#{display}</code>\"\n })\n end"
] |
[
"0.77627116",
"0.70357776",
"0.687819",
"0.642321",
"0.6366342",
"0.63557315",
"0.63054556",
"0.61518234",
"0.6036808",
"0.5992619",
"0.59743303",
"0.59697795",
"0.59416395",
"0.59394103",
"0.59263223",
"0.5892963",
"0.58894134",
"0.588759",
"0.58850175",
"0.5856869",
"0.5856869",
"0.58298695",
"0.5825608",
"0.5822289",
"0.57994175",
"0.57845914",
"0.57845914",
"0.5784318",
"0.5772408",
"0.57560915",
"0.5755046",
"0.5740275",
"0.57283443",
"0.5693386",
"0.5687381",
"0.56837004",
"0.56662375",
"0.56638694",
"0.56510895",
"0.56482744",
"0.5648072",
"0.56385154",
"0.5634837",
"0.56328166",
"0.5630374",
"0.56195825",
"0.55927634",
"0.55808717",
"0.55675846",
"0.55668557",
"0.554497",
"0.5540692",
"0.5531323",
"0.5528761",
"0.55263287",
"0.5525298",
"0.5522292",
"0.5507863",
"0.549945",
"0.5496438",
"0.5496208",
"0.5490074",
"0.5487499",
"0.5478195",
"0.5473654",
"0.5471687",
"0.54547715",
"0.54480493",
"0.5443036",
"0.5439219",
"0.54366314",
"0.54299444",
"0.5426106",
"0.5416525",
"0.5416525",
"0.5416525",
"0.5415874",
"0.54150206",
"0.5407222",
"0.54070705",
"0.5405121",
"0.5392977",
"0.5387917",
"0.5383055",
"0.53800136",
"0.5372388",
"0.5370498",
"0.53695995",
"0.53634816",
"0.5359231",
"0.5356026",
"0.5341208",
"0.5338843",
"0.533669",
"0.5334445",
"0.533176",
"0.5330175",
"0.53248215",
"0.5312289",
"0.53074384"
] |
0.6872888
|
3
|
User calls an elevator
|
def requestElevator(floor, direction)
puts "A request for an elevator is made from floor #{floor}, going #{direction}."
elevator = findBestElevator(floor, direction)
puts "Elevator #{elevator.elevatorId} is the best elevator, so it is sent."
elevator.elevatorFloorRequestList.push(floor)
elevator.sortFloorList()
puts "Elevator is moving."
elevator.moveElevator()
puts "Elevator is #{elevator.elevatorStatus}."
elevator.doorController()
return elevator
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def call_elevator elevator_number=0\n\t\t@elevators[elevator_number].add_to_floors_to_visit @floor_number\n\tend",
"def requestElevator(requestedFloor, direction)\n if direction == ButtonDirection::UP\n @buttonsUpList[requestedFloor-1].status = ButtonStatus::ON\n else\n @buttonsDownList[requestedFloor-2].status = ButtonStatus::ON\n end\n\n puts \">> Someone request an elevator from floor <#{requestedFloor}> and direction <#{direction}> <<\"\n for x in @elevatorsList do\n puts \"Elevator#{x.id} | Floor: #{x.floor} | Status: #{x.status}\"\n end\n\n bestElevator = findElevator(requestedFloor, direction)\n bestElevator.addFloorToFloorList(requestedFloor) \n bestElevator.moveElevator(requestedFloor, self)\n end",
"def elevator\n elevators.sort_by { |e| e.stop_count }.first\n end",
"def request_elevator(requested_floor, direction)\n if direction == \"up\"\n call_btn_to_press = @up_call_buttons.find { |btn| btn.floor == requested_floor } \n elsif direction == \"down\"\n call_btn_to_press = @down_call_buttons.find { |btn| btn.floor == requested_floor } \n end\n\n chosen_elevator = call_btn_to_press.press()\n chosen_elevator.do_requests()\n\n return chosen_elevator\n end",
"def send_request(elevator)\n request = Request.new(@floor, @direction)\n elevator.requests_queue.append(request)\n end",
"def request_this_elevator()\n self.set_direction\n self.status_update\n case self.direction\n when 0\n self.set_direction\n when 1\n if self.current_floor == self.up_queue[0]\n self.up_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor + 1\n\n if self.up_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n when -1\n if self.current_floor == self.down_queue[0]\n self.down_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor - 1\n if self.down_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n end\n end",
"def choose_elevator\n elevator_scores = []\n\n for elevator in @column.elevator_list do\n \n # Initialize score to 0\n score = 0\n floor_difference = elevator.current_floor - @floor\n\n # Prevents use of any offline/under-maintenance elevators\n if elevator.status != \"online\"\n score = -1\n elevator_scores.append(score)\n else\n\n # Bonify score based on difference in floors\n if floor_difference == 0\n score += 5000\n else\n score += 5000/(floor_difference.abs() + 1)\n end\n \n # Bonify score based on direction (highest priority)\n if elevator.movement != \"idle\"\n if floor_difference >= 0 and @direction == \"down\" and elevator.movement == \"down\"\n \n # Paths are crossed going down, therefore favor this elevator\n score += 10000\n \n elsif floor_difference <= 0 and @direction == \"up\" and elevator.movement == \"up\"\n\n # Paths are crossed going down, therefore favor this elevator\n score += 10000\n \n else\n \n # Paths are not crossed, therefore try avoiding the use of this elevator\n score = 0\n \n # Give redemption points, in worst case scenario where all elevators never cross paths\n next_floor_difference = elevator.next_floor - @floor\n if next_floor_difference == 0\n score += 500\n else\n score += 500/(next_floor_difference.abs() + 1)\n end\n end\n end\n\n # Bonify score on request queue size (the smaller number of pre-existing requests, the faster therefore the better)\n if elevator.requests_queue.length() <= 3\n score += 1000\n elsif elevator.requests_queue.length() <= 7\n score += 250\n end\n \n # Send total score of elevator to the scores list\n elevator_scores.append(score)\n end\n end\n\n # Get value of highest score\n highest_score = -1\n for score in elevator_scores do\n if (score > highest_score)\n highest_score = score\n end\n end\n \n # Get elevator with the highest score (or nil if all elevators were offline\n chosen_elevator = nil\n if (highest_score > -1)\n chosen_elevator = @column.elevator_list[elevator_scores.find_index(highest_score)]\n puts \"Chosen elevator: Elevator #{chosen_elevator.id}\"\n end\n return chosen_elevator\n end",
"def board_elevator(elevator)\n elevator_direction = elevator.direction\n elevator_num = elevator.number\n if elevator.direction == \"up\"\n #board_people(elevator, @up_person_queue, @up_request_pending)\n board_people_up(elevator)\n @button_pairs[\"elevator#{elevator_num}\"][\"up\"] = false\n elsif elevator.direction == \"down\"\n #board_people(elevator, @down_person_queue, @down_request_pending)\n board_people_down(elevator)\n @button_pairs[\"elevator#{elevator_num}\"][\"down\"] = false\n end\n end",
"def next_elevator\n strategies.map { |strategy| strategy.elevator(elevators, request) }.first\n end",
"def request_floor(elevator, requested_floor)\n floor_btn_to_press = elevator.floor_buttons.find { |btn| btn.floor == requested_floor } \n \n floor_btn_to_press.press()\n elevator.do_requests()\n end",
"def clock_tick\n\t\t@elevator_strategy.has_incoming_elevators?(self)\n\t\tif not @passengers.empty? && @make_new_request == false\n\t\t\t@elevator_strategy.request_elevator(self)\n\t\t\t@make_new_request = false\n\t\tend\n\tend",
"def scenario1()\n puts \"\"\n puts \"****************************** SCENARIO 1: ******************************\"\n columnScenario1 = Column.new(1, ColumnStatus::ACTIVE, 10, 2) #parameters (id, ColumnStatus.ACTIVE/INACTIVE, numberOfFloors, numberOfElevators)\n columnScenario1.display() \n columnScenario1.elevatorsList[0].floor = 2 #floor where the elevator 1 is\n columnScenario1.elevatorsList[1].floor = 6 #floor where the elevator 2 is\n \n puts \"\"\n puts \"Person 1: (elevator 1 is expected)\"\n columnScenario1.requestElevator(3, ButtonDirection::UP) #parameters (requestedFloor, buttonDirection.UP/DOWN)\n columnScenario1.elevatorsList[0].requestFloor(7, columnScenario1) #parameters (requestedFloor, requestedColumn)\n puts \"==================================\"\nend",
"def load_elevator\n while(@elevator.has_room? && @floors[0].is_empty?)\n @elevator.enter(@floors[0].dequeue)\n end\n end",
"def go_to_origin\n @next_floor = @origin_floor\n puts \"Elevator #{@id} going back to origin...\"\n go_to_next_floor()\n end",
"def requestFloor(floor)\n puts \"The elevator is requested to move to floor #{floor}.\"\n @floorRequestList.push(floor)\n sortFloorList()\n puts \"Elevator is moving.\"\n moveElevator()\n puts \"Elevator is #{@status}.\"\n doorController()\n if @floorRequestList.length() == 0\n @direction = nil\n @status = 'idle'\n end\n puts \"Elevator is #{@status}.\"\n end",
"def display_floor\n sleep($sleep_time)\n puts \"... Elevator #{@elevator.id}'s current floor mid-travel #{@elevator.current_floor} ...\"\n end",
"def elevator_pitch\n puts \"%s, %s\" % [@name, @description]\n end",
"def work\n @elevator_controller = ElevatorController.find(params[:id])\n @elevator_controller.work\n redirect_to action: \"show\"\n end",
"def elevator\n if params[:column].present?\n @elevator = Elevator.where(column_id:params[:column])\n else\n @elevator = Elevator.all\n end\n\n respond_to do |format|\n format.json {\n render json: {elevator: @elevator}\n \n }\n end\n end",
"def makeElevator\n for elevatorID in 1..@amountOfElevators\n elevator = Elevator.new(elevatorID, 'idle', @amountOfFloors, 1)\n @elevatorsList.push(elevator)\n end\n end",
"def elevator_print(floor)\r\n\t\televator_list.each do |elevator|\r\n\t\t\tif(floor.get_position == elevator.get_floor)\r\n\t\t\t\televator.to_s\r\n\t\t\tend\r\n\t\tend\r\n\t\tputs\r\n\tend",
"def receive_call(requested_direction, requested_floor)\n (invalid_direction_warning(requested_direction) and return) unless valid_direction?(requested_direction)\n (invalid_floor_warning(requested_floor) and return) unless valid_floor?(requested_floor)\n\n elevator = find_closest_eligible_elevator(requested_direction, requested_floor)\n elevator.add_floor_to_destination_queue(requested_floor)\n elevator.perform_moves unless elevator.in_use?\n end",
"def findNearestElevator(currentFloor, selectedList)\n bestElevator = selectedList[0]\n bestDistance = (selectedList[0].floor - currentFloor).abs #abs() returns the absolute value of a number (always positive).\n \n for elevator in selectedList\n if (elevator.floor - currentFloor).abs < bestDistance\n bestElevator = elevator\n end\n end\n \n puts \"\"\n puts \" >> >>> ELEVATOR #{bestElevator.id} WAS CALLED <<< <<\"\n return bestElevator\n end",
"def receive_internal_request(elevator_id, requested_floor)\n (invalid_elevator_warning(elevator_id) and return) unless valid_elevator_id?(elevator_id)\n (invalid_floor_warning(requested_floor) and return) unless valid_floor?(requested_floor)\n\n elevator = @elevators.detect { |e| e.id == elevator_id }\n elevator.add_floor_to_destination_queue(requested_floor)\n elevator.perform_moves unless elevator.in_use?\n end",
"def send_request\n request = Request.new(@floor, @direction)\n @elevator.requests_queue.append(request)\n end",
"def main_menu\n menu_options = [\"Start exploring\", \"Check Inventory\", \"Check Your Score\", \"Go to Pokemon Center\", \"Quit\"]\n menu_prompt = Interactivity.mainMenu \n \n if user.pokemon == nil\n menu_options.shift()\n menu_options.unshift(\"Choose a Pokemon and start exploring\")\n elsif self.user_current_location\n menu_options.shift()\n menu_options.unshift(\"Keep Exploring\")\n end\n \n choice = prompt.select(menu_prompt, menu_options) \n if choice == \"Start exploring\" || choice == \"Choose a Pokemon and start exploring\" || choice == \"Keep Exploring\"\n self.trainer_chooses_pokemon if user.pokemon == nil \n self.trainer_chooses_town\n self.exploring_town\n elsif choice == \"Check Inventory\"\n puts \"MANAGE INVENTORY - CHANGE POKEMONS AROUND\"\n elsif choice == \"Go to Pokemon Center\"\n self.pokemon_center\n elsif choice == \"Check Your Score\"\n puts \"CHECK YOUR SCORE\"\n else\n Interactivity.quit\n end\n end",
"def requestFloor(requestedFloor, requestedColumn)\n puts \"\" \n puts \">> Someone inside the elevator#{@id} wants to go to floor <#{requestedFloor}> <<\"\n checkWeight($maxWeight)\n checkObstruction()\n addFloorToFloorList(requestedFloor)\n moveElevator(requestedFloor, requestedColumn)\n end",
"def find_closest_eligible_elevator(requested_direction, requested_floor)\n closest_eligible_elevator = elevators_sorted_by_call_proximity(requested_floor).detect do |e|\n e.eligible_for_pickup?(requested_direction, requested_floor)\n end\n if closest_eligible_elevator\n closest_eligible_elevator\n else\n find_closest_eligible_elevator(requested_direction, requested_floor)\n end\n end",
"def elevators_at_floor(floor)\n\t\televators.select{|elevator| elevator.floor.eql? floor}\n\tend",
"def view_appointment\n if @client.appointments.length < 1\n puts \"You currently have no appointments\"\n sleep(2)\n else \n puts \"Here are your appointments:\"\n @client.appointments.pluck(:time).each { |time| puts \" - #{time}\" } \n @prompt.select \"\" do |m| \n m.choice \"<Go Back>\", -> { appointment_system }\n end\n end\n appointment_system\n end",
"def get_elevator\n if params[:column].present?\n @elevators = Column.find(params[:column]).elevators\n else\n @elevators = Column.all\n end\n if request.xhr?\n respond_to do |format|\n format.json {\n render json: {elevators: @elevators}\n }\n end\n end\n end",
"def findElevator(currentFloor, direction)\n activeElevatorList = []\n idleElevatorList = []\n sameDirectionElevatorList = []\n for x in @elevatorsList\n if x.status != ElevatorStatus::IDLE #verify if elevator is active and if the request is on the elevator way\n if x.status == ElevatorStatus::UP and x.floor <= currentFloor or x.status == ElevatorStatus::DOWN and x.floor >= currentFloor\n activeElevatorList.append(x)\n end\n else\n idleElevatorList.append(x)\n end\n end\n\n if activeElevatorList.length > 0 #Create new list for elevators with same direction that the request\n sameDirectionElevatorList = activeElevatorList.select {|elevator| elevator.status == direction}\n end\n \n if sameDirectionElevatorList.length > 0\n bestElevator = findNearestElevator(currentFloor, sameDirectionElevatorList)\n else\n bestElevator = findNearestElevator(currentFloor, idleElevatorList)\n end\n \n return bestElevator\n end",
"def step\n halt if should_halt?\n stop_elevator or move_elevator\n end",
"def getelevators\n puts params\n elid = params[\"columnid\"]\n\n elevators = Elevator.where(:column_id => elid)\n\n puts elevators.inspect\n \n respond_to do |format|\n format.json { render json: elevators }\n end\n end",
"def view_appointment\n if @patient.appointments.length < 1\n puts \"You currently have no appointments\"\n sleep(2)\n else \n puts \"Here are your appointments:\"\n @patient.appointments.pluck(:time, :doctor_id).each { |array| puts \" - #{array[0]} -- #{Doctor.find(array[1]).name}\" }\n @prompt.select \"\" do |m| \n m.choice \"<Go Back>\", -> { appointment_system }\n end\n\n end\n appointment_system\n end",
"def create_elevators\n @elevator_number.times do |i|\n floor_gap = @building.floors / @elevator_number * i\n elevator_list.append(Elevator.new(i, 1 + floor_gap, 1 + floor_gap))\n end\n end",
"def set_direction()\n case self.direction\n when 0\n if self.up_queue.length > self.down_queue.length\n self.direction = 1\n elsif self.up_queue.length < self.down_queue.length\n self.direction = -1\n else\n self.direction = 0\n end\n when 1\n if self.up_queue.length > 0\n self.direction = 1\n elsif self.up_queue.length == 0\n if self.down_queue.length > 0\n self.direction = -1\n else\n self.direction = 0\n end\n end\n when -1\n if self.down_queue.length > 0\n self.direction = -1\n elsif self.down_queue.length == 0\n if self.up_queue.length > 0\n self.direction = 1\n else\n self.direction = 0\n end\n end\n end\n\n # handles requests while its queue is not empty\n\n def request_this_elevator()\n self.set_direction\n self.status_update\n case self.direction\n when 0\n self.set_direction\n when 1\n if self.current_floor == self.up_queue[0]\n self.up_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor + 1\n\n if self.up_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n when -1\n if self.current_floor == self.down_queue[0]\n self.down_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor - 1\n if self.down_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n end\n end\n\n # responds to floor requests from within the elevator\n\n def request_floor(floor)\n if floor == self.current_floor\n print self.id 'floor button pushed, we are already on this floor, opening doors'\n elsif floor > self.current_floor\n self.a_floor_was_requested(floor)\n self.up_queue.append(floor)\n self.up_queue.sort\n self.set_direction\n self.request_this_elevator\n elsif floor < self.current_floor\n self.a_floor_was_requested(floor)\n self.down_queue.append(floor)\n self.up_queue.sort.reverse\n self.set_direction\n self.request_this_elevator\n end\n end\n end",
"def employee_menu\n header(\"employee functions\")\n puts\n\n #TTY::Prompt keypress method constantly monitors keyboard for input\n @prompt = TTY::Prompt.new\n\n puts \"1) view the employee roster\"\n puts\n puts \"2) add employee\"\n puts\n puts \"3) update employee details\"\n puts\n puts \"4) delete employee\"\n puts\n puts \"5) return to main menu\"\n puts\n\n selection = @prompt.keypress(\"Please make your selection:\").to_i\n case selection\n when 1\n view_employee_roster\n system \"clear\"\n employee_menu\n when 2\n add_employee\n system 'clear'\n employee_menu\n when 3\n view_employee_roster\n update_employee\n system 'clear'\n employee_menu\n when 4\n view_employee_roster\n delete_employee\n system 'clear'\n employee_menu\n when 5\n system \"clear\"\n main_menu\n else\n error\n press_any_key\n end\n end",
"def moveElevator(requestedFloor, requestedColumn)\n while @floorList.length() != 0\n if @status == ElevatorStatus::IDLE\n if @floor < requestedFloor\n @status = ElevatorStatus::UP\n elsif @floor == requestedFloor\n openDoors($waitingTime)\n deleteFloorFromList(requestedFloor)\n requestedColumn.buttonsUpList[requestedFloor-1].status = ButtonStatus::OFF\n requestedColumn.buttonsDownList[requestedFloor-1].status = ButtonStatus::OFF\n @floorButtonsList[requestedFloor-1].status = ButtonStatus::OFF\n else\n @status = ElevatorStatus::DOWN\n end\n end\n\n if @status == ElevatorStatus::UP\n moveUp(requestedColumn)\n else\n moveDown(requestedColumn)\n end\n\n end\n end",
"def createElevatorsList\n for x in 1..@numberOfElevators do\n @elevatorsList.append(Elevator.new(x, @numberOfFloors, 1, ElevatorStatus::IDLE, SensorStatus::OFF, SensorStatus::OFF))\n # puts \"elevator#{@id} created\"\n end\n end",
"def main\n hotel = Hotel::HotelController.new\n\n puts \"\\nWelcome to Hotel Ada Lovelace!\"\n choice = \"\"\n while choice != \"exit\"\n puts \"\\nHotel Main Menu:\"\n puts \"1 - Make Reservation (mr, r)\"\n puts \"2 - Make Block (mb, b)\" \n puts \"3 - Make Block Reservation (mbr, br)\"\n puts \"4 - Show Reservations (sr, s)\"\n puts \"5 - Show Blocks (sb)\"\n puts \"6 - Exit (x, q)\"\n print \"\\nWhat would you like to do? \"\n choice = gets.chomp.downcase\n case choice\n when \"make reservation\", \"reservation\", \"mr\", \"r\", \"1\"\n make_reservation(hotel)\n when \"make block\", \"block\", \"mb\", \"b\", \"2\"\n make_block(hotel)\n when \"make block reservation\", \"mbr\", \"br\", \"3\"\n make_block_reservation(hotel)\n when \"show reservations\", \"sr\", \"s\", \"4\"\n show_reservations(hotel)\n when \"show blocks\", \"sb\", \"5\"\n show_blocks(hotel)\n when \"exit\", \"x\", \"quit\", \"q\", \"e\", \"6\"\n choice = \"exit\"\n else\n puts \"Invalid choice!\"\n end\n end\nend",
"def step\n\t\t@elevators.each do |elevator|\n\t\t\tif elevator.current_floor == @floor_number\n\t\t\t\twhile !@persons_queue.empty?\n\t\t\t\t\tif elevator.number_of_occupants < elevator.max_capacity\n\t\t\t\t\t\televator.add_occupant @persons_queue.shift\n\t\t\t\t\telse\n\t\t\t\t\t\tbreak\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def main_menu(owner_name, owner)\n puts \"#{page_break}\\n\n Select from the following menu options to get started:\\n\n 1 - Make New Appointent\n 2 - Reschedule Appointment\n 3 - Cancel Appointment\n 4 - Search for a Groomer\n 5 - Exit\n \"\n end",
"def add_elevators(starting_floor, number_of_elevators)\n\t\tnumber_of_elevators.times do\n\t\t\te = Elevator.new(starting_floor, @elevator_strategy)\n\t\t\t@elevators << e\n\t\t\t@sim.register(e)\n\t\tend\n\tend",
"def go_to_next_floor\n puts \"Elevator #{@id}, currently at floor #{@current_floor}, is about to go to floor #{@next_floor}...\"\n puts \"=====================================================================\"\n \n while @current_floor != @next_floor\n if @movement == \"up\"\n @current_floor += 1\n elsif (@movement == \"down\")\n @current_floor -= 1\n end\n @floor_display.display_floor()\n end\n\n puts \"======================================================================\"\n puts \"Elevator #{@id} has reached its requested floor! It is now at floor #{@current_floor}.\"\n end",
"def triage_select\n case params['Digits']\n when '*'\n @phone_call.miss! 'after_hours'\n render action: :goodbye, formats: [:xml]\n return\n when '1'\n @phone_call.transfer! Member.robot\n @phone_call.miss! 'after_hours'\n @nurseline_phone_call = @phone_call.transferred_to_phone_call\n render action: :transfer_nurse, formats: [:xml]\n return\n end\n\n redirect_to action: :triage_menu, id: @phone_call.id\n end",
"def elevator_select\n p params[\"column_id\"]\n @elevators = Elevator.where(column_id: params[\"column_id\"])\n respond_to do |format |\n format.json {\n render json: {\n elevators: @elevators\n }\n }\n end\n end",
"def elevator_pitch\r\n \"#{@name}, #{@description}\"\r\n end",
"def route_menu_hint\n puts ''\n puts '=== route_Menu_Hint ==='\n routes_list_show\n name = @routes[@routes_ptr]&.first_last_name\n puts \"current route => #{name}\"\n route_stations_list_show\n puts '1 : add new route'\n puts '2 : select next route in list'\n puts '3 : select prev route in list'\n puts '4 : add station to route'\n puts '5 : remove station from route'\n puts '0: return to main menu'\nend",
"def call\n tg = TicketGroup.find(params[:ticket_group_id])\n event_name = 'testing name'\n row = 'test row'\n section = 'test section'\n if tg\n event = tg.custom_event\n event_name = event.name\n section = tg.section\n row = tg.row\n end\n if session[:buyer]\n buyer = Buyer.find(session[:buyer])\n hit_tropo_end_point({\n 'name' => buyer.first_name,\n 'event_name' => event_name,\n #'section' => section,\n #'row' => row,\n 'action' => 'voice',\n 'call_type' => AppSettings::CALL_TYPE[:voice]\n })\n flash[:message] = \"successfully called!\"\n else\n respond_to do |format|\n flash[:error] = \"sign up or sign in as a buyer first!\"\n format.html { redirect_to(\"/buyers/new\")}\n end\n end\n end",
"def set_elevator_booking\n @elevator_booking = ElevatorBooking.find(params[:id])\n end",
"def login\n puts \"Welcome to Singh Accounting Online Appointment System\"\n @prompt.select \"Are you a returning client?\" do |menu|\n menu.choice \"Yes\", -> do\n phone = @prompt.ask(\"Please Enter Your Phone Number\")\n @client = Client.find_by(phone: phone)\n \n \n\n if @client.nil?\n puts \"Sorry, cannot find client with that phone\"\n @prompt.select \"What would you like to do?\" do |m|\n m.choice \"Try Again\", -> { login }\n m.choice \"Create Account\", -> { new_client }\n m.choice \"Exit\", -> { exit_method }\n end\n end\n end\n\n menu.choice \"No (Create New Client Portal)\", -> { new_client }\n menu.choice \"Exit The System\", -> { exit_method }\n \n \n \n end\n end",
"def enter_room\n time = Time.now\n time_future = time + 100*60*60\n# Inform user of current status\n\tputs \"\\nYou awake in a small room.\"\n print \"...the date is \"\n puts time_future\n puts \"\\nFours days after your accident!\\n\\n\"\n\tputs \"There is a large door in the distance that is locked.\"\n\tputs \"In front of you is a small table.\\n\\n\"\n\tputs \"You walk towards the table.\\n\\n\"\n\tdesk_options\nend",
"def amend\n @leave_request = current_account.leave_requests.find_by_identifier(params[:id])\n \n leave_request_params = {\n :tenant => current_account.subdomain,\n :request => @leave_request\n }\n \n # check whether this leave request is captured, and route onto the staff requests view\n if @leave_request.captured?\n redirect_to new_staff_leave_request_url(leave_request_params)\n else\n redirect_to new_employee_leave_request_url(leave_request_params)\n end\n \n end",
"def main_menu(user)\n calories = Calories.new\n loop do\n calories.calorie_intake(user)\n case Prompts.main_selection\n when '1'\n calories.log_daily_meals\n when '2'\n calories.log_daily_intake\n when '3'\n Details.update_weight(user)\n when '4'\n Quotes.inspirational\n when '5'\n quit\n end\n end\n end",
"def planner\n\n @response = CompanyApi::Request::Economy.new(\n CompanyApi::Response::Formatter::Economy,\n request.cookies,\n {\"User-Agent\" => http_user_agent}\n ).fetch_planner_step_one_details\n\n # Check if error present or not?\n unless @response.success?\n render_error_response(@response)\n return\n end\n\n @presenter_obj = ::WebPresenter::Economy::Planner.new(@response, params)\n\n end",
"def officer\n redirect_to root_path, notice: \"You are not authorized to do that\" if !current_member.officer?\n end",
"def state\n\t\t@flrs.each do |f|\n\t\t\tputs \"Floor #{@flrs.index(f)} has #{f.passengers.length} passengers waiting.\"\n\t\tend\n\t\t@elevators.each do |e|\n\t\t\tputs \"Elevator #{@elevators.index(e)} is in floor #{@flrs.index(e.current_floor)}, #{e.direction} with #{e.passengers.length} passengers\"\n\t\tend\n\tend",
"def run_menu_and_call_next(menu)\n user_wants = run_menu(menu)\n params = user_wants.slice(1..-1) if user_wants.length > 1\n call_method(user_wants.slice(0), params)\n end",
"def set_elevator_form\n @elevator_form = ElevatorForm.find(params[:id])\n end",
"def list_option\n list_politicians\n list_voters\n puts\n puts \"(R)eturn to the main menu?\".center(80).green\n menu_return = gets\n end",
"def tick\n\t\t@elevators.each{|elevator| elevator.tick}\n\t\t@floors.each{|floor| floor.tick}\n\tend",
"def offices\n \n end",
"def find_elevators_by_direction(elevator_direction)\n same_direction = @elevator_list.select { |elevator| elevator.direction == elevator_direction }\n idle = @elevator_list.select { |elevator| elevator.direction.zero? }\n if same_direction.length > 0\n return same_direction\n else\n return idle\n end\n end",
"def options_when_walking_away_from_desk\n# letting user know whats happening with the door\n puts \"\\nYou walk to the door and... \"\n sleep(2)\n if $items_collected.include?(\"key\") then\n puts \"You use the key to open the door\"\n sleep(2)\n opened_the_door_walked_outside\n else !$items_collected.include?(\"key\")\n puts \"Sorry you dont have the key, go back to the desk!\\n\\n\"\n sleep(2)\n remove_last_item_from_items_collected_at_desk\n end\nend",
"def main_menu\n choice = true\n while choice\n puts \"What would you like to do?\"\n puts \"(C)reate, (L)ist, (U)pdate, (D)elete, or (E)xit \"\n options = gets.chomp.downcase\n\n case options\n when \"c\"\n # runs method create line 101\n create\n when \"l\"\n #runs method list line 144\n list\n when \"u\"\n #runs method update line 161\n update\n when \"d\"\n #runs method delete line 229\n delete\n when \"e\"\n choice = false #exits world\n else\n puts \"Wrong Input. Please input C, L, U, D or E\"\n end\n end\n end",
"def call \n user\n end",
"def peacekeeper_quest; end",
"def invitee_action\n begin\n if check_magic_token\n\n event_type = params[:event]\n calendar_email = params[:payload][:event][:extended_assigned_to][0][:email] # This is the email of the account used to create the calendar\n email = params[:payload][:invitee][:email]\n first_name = params[:payload][:invitee][:first_name]\n last_name = params[:payload][:invitee][:last_name]\n event_name = params[:payload][:event_type][:name]\n start_time = params[:payload][:event][:invitee_start_time_pretty]\n\n\n contact = {}\n contact['FirstName'] = first_name\n contact['LastName'] = last_name unless last_name.blank?\n contact['Email'] = email\n\n applicant_type = 'event_volunteer'\n selected_timeslot = \"#{event_name}: #{start_time}\"\n\n bz_region = User.get_bz_region(applicant_type, calendar_email)\n if bz_region.nil?\n raise NoRegionMappingException \"No bz_region set b/c we haven't mapped the calendar #{calendar_email} to a region for #{applicant_type}\"\n end\n\n if event_type == 'invitee.created'\n calendly_url = User.get_calendar_url(bz_region)\n phone = nil\n company = nil\n title_industry = nil\n city_state = nil\n career = nil\n params[:payload][:questions_and_answers].each do |qa|\n if qa[:question].downcase.include?('phone')\n phone = qa[:answer]\n elsif qa[:question].downcase.include?('employer')\n company = qa[:answer]\n elsif qa[:question].downcase.include?('title')\n title_industry = qa[:answer]\n elsif qa[:question].downcase.include?('career')\n career = qa[:answer]\n elsif qa[:question].downcase.include?('city, state')\n city_state = qa[:answer]\n end\n end\n\n # Note: city_state is supposed to be in the format: City, State. E.g. Brooklyn, NY\n # If it's not, just set the city to the whole string\n city = city_state.split(',')[0]\n state = city_state.split(',')[1]\n\n # Create a BZ User in this platform\n current_user = User.find_by_email(email)\n if current_user.nil?\n current_user = User.new(:first_name => first_name, :last_name => last_name, :email => email, :phone => phone, :applicant_type => applicant_type, :city => city, :state => state, :external_referral_url => calendly_url, :bz_region => bz_region)\n else\n current_user.bz_region = bz_region\n current_user.applicant_type = applicant_type\n end\n current_user.skip_confirmation!\n current_user.save!\n\n # Create the user in salesforce\n contact['Phone'] = phone\n contact['Signup_Date__c'] = DateTime.now\n contact['MailingCity'] = city\n contact['MailingState'] = state unless state.nil?\n contact['Company__c'] = company\n contact['Title'] = title_industry # Both their title and industry could have commans, so can't split reliable. Just stuff it all in Title field.\n contact['Career__c'] = career\n contact['BZ_Region__c'] = bz_region\n contact['User_Type__c'] = 'Event Volunteer'\n contact['BZ_User_Id__c'] = current_user.id\n contact['Came_From_to_Visit_Site__c'] = calendly_url\n\n salesforce = BeyondZ::Salesforce.new\n existing_salesforce_id = salesforce.exists_in_salesforce(email)\n client = salesforce.get_client\n if !existing_salesforce_id.nil?\n client.update('Contact', existing_salesforce_id, contact)\n else\n # There is a bug in calendly where Last Name is not actually a required field.\n # This is meant to put something in that field so at least a Salesforce record is created.\n contact['LastName'] = '<Missing>' if last_name.blank?\n\n # Note: for new users that volunteer, we don't create BZ Users. We just populate a new Salesforce\n # contact as though it was done manually. Only Fellows and LCs get BZ Users after this calendly integration goes live.\n contact['LeadSource'] = 'Volunteer Signup'\n contact['OwnerId'] = current_user.salesforce_lead_owner_id # Note that if they are already in Salesforce, we assume they have an Owner already.\n contact = client.create('Contact', contact)\n existing_salesforce_id = contact.Id\n end\n\n current_user.salesforce_id = existing_salesforce_id\n current_user.skip_confirmation!\n current_user.save!\n \n cm = current_user.auto_add_to_salesforce_campaign('Confirmed', selected_timeslot)\n if cm.nil?\n logger.debug \"######## Failed to create Campaign Member for #{current_user.inspect}. Dunno why though.\"\n end\n\n current_user.create_mailchimp\n\n elsif event_type == 'invitee.canceled'\n current_user = User.find_by_email(email)\n if !current_user.nil?\n current_user.bz_region = bz_region\n current_user.applicant_type = applicant_type\n cancellation_reason = params[:payload][:invitee][:cancel_reason]\n current_user.cancel_volunteer_signup(selected_timeslot, cancellation_reason)\n else\n logger.warn \"No user with email = #{email} found -- NOOP\"\n end\n\n else\n logger.warn \"Unrecognized event type found: #{event_type} -- NOOP\"\n end\n end\n # Need to catch all exceptions and always report that it was OK b/c Calendly will put the webhook\n # in a failed state and stop calling our endpoint until we delete and re-register the hook.\n rescue Exception => e\n logger.warn \"###### Caught #{e.inspect} -- may have failed to add the Volunteer signup information into Salesforce.\"\n end\n\n render plain: 'OK'\n end",
"def here\n if @zone_cur == 0\n narrate(\"you are currently at the #{self.name} entrance\")\n elsif @zone_cur == 10\n narrate(\"you are currently at the #{self.name} exit!\")\n else\n narrate(\"you are currently in the #{self.name}\")\n end\n actions\n end",
"def invite\n \n end",
"def loc_time_menu\n loc_time = Menu.new(\"What would you like to do with movie time/theatre slots?\")\n loc_time.add_menu_item({key_user_returns: 1, user_message: \"Create a new theatre/time slot.\", do_if_chosen: \n [\"create_loc_time\"]})\n loc_time.add_menu_item({key_user_returns: 2, user_message: \"Update a theatre/time slot.\", do_if_chosen: \n [\"update_object\", LocationTime, \"loc_time_menu\"]})\n loc_time.add_menu_item({key_user_returns: 3, user_message: \"Show me theatre/time slots.\", do_if_chosen: \n [\"show_object\", LocationTime, \"loc_time_menu\"]})\n loc_time.add_menu_item({key_user_returns: 4, user_message: \"Delete a theatre/time slot.\", do_if_chosen: \n [\"delete_loc_time\"]})\n loc_time.add_menu_item({key_user_returns: 5, user_message: \"Return to main menu.\", do_if_chosen: \n [\"main_menu\"]})\n run_menu_and_call_next(loc_time)\n end",
"def call_option(user_selected) \n\t case user_selected\n\t when 1 then add_new_contact\t\t\n\t when 2 then modify_existing_contact\n\t when 3 then display_one_contact\n\t when 4 then delete_contact\n\t when 5 then display_all_contacts\n\t when 6 then display_by_attribute\n\t when 7\n\t\t\tputs \"Current session ended, goodbye!\"\n\t\t\treturn\n\t\telse\n\t\t\tputs \"Invalid Option, try again.\"\n\t\t\treturn\n\t\tend\t\n\tend",
"def guest_edit\n # If the use IS logged in, redirect them to the home page. The guest edit is only for users not logged in.\n if current_user == nil && session[:trip] != nil\n @trip = session[:trip]\n\n if remotipart_submitted?\n begin\n travellers = process_trip_travellers(params[:trip][:traveller_csv])\n travellers.each do |t|\n @trip.travellers << t\n end\n rescue ArgumentError => e\n @error_msg = e.message\n end\n end\n\n session[:trip] = @trip\n else\n redirect_to pages_home_path\n end\n end",
"def main_menu\n while true\n puts \"Options:\"\n puts \"[1] Add a new field of crops\"\n puts \"[2] Harvest crops\"\n puts \"[3] Status of farm\"\n puts \"[4] Relax and view fields\"\n puts \"[5] Exit\"\n puts \"Enter a Number\"\n main_menu_opt = gets.chomp.to_i\n case main_menu_opt\n when 1 then field #will run field method\n when 2 then harvest #will run harvest method\n when 3 then status #will run status method\n when 4 then relax #will run relax method\n else exit\n end\n end\n end",
"def sub_request\n (@shift = find_params_id(Shift)) || return\n \n @sub = Sub.new(params[:sub]) do |s|\n s.bribe_start = s.bribe_end = nil unless s.bribe_flag==\"1\"\n end\n \n @sub.shift = @shift #sub belongs to a shift\n @sub.user = @shift.user #sub belongs to requestor, need this bcoz if parent shift is deleted, still can track user \n\n #need to map time_choices to the following to use in the view page. -H\n @time_choices_select = time_select_for(@shift.start, @shift.end)\n if request.post? #if request is submitted and max not reached\n @sub.email_to = @shift.location.location_group.sub_email #request email when offer_to is blank (ALL) \n offered_names = []\n \n unless @sub.offer_to.blank? #if specific login_or_name_list are entered, email these people separately\n login_or_name_list = @sub.offer_to.split(',').reject {|n| n.blank?} #delete all nil/empty elements from the array.\n unless login_or_name_list.empty?\n @sub.email_to = [] #prepare list of emails\n login_or_name_list.each do |login_or_name|\n login_or_name.strip! #remove leading, trailing space. (very impt)\n user = User.find_by_login(login_or_name) || User.find_by_name(login_or_name)\n if user.nil?\n @sub.errors.add(:offer_to, \"invalid netid or name: #{login_or_name}\")\n else\n @sub.add_eligible(user)\n @sub.email_to << user.email\n offered_names << user.name\n end\n end\n end\n end\n \n @allowed = (from_admin? || !@sub.exceed_max?(add_public_sub = offered_names.empty?))\n \n #check errors first to make sure all names were entered correctly\n if @sub.errors.empty? and @sub.save\n email = ShiftMailer.create_send_request(@sub, \n url_for(:controller => 'shift', :action => 'sub_accept', :id => @sub) )\n ShiftMailer.deliver(email)\n offered_names = ['everybody'] if offered_names.empty?\n redirect_with_flash \"Sub requested, sent to #{offered_names}\", :action => :index, :date => @shift.shift_date, :anchor => @shift.shift_date\n \n #comment this line and uncomment above deliver email line if you want to have emails sent\n #render(:text => '<pre>' + email.encoded + '</pre>') #debugging purpose\n end \n end\n end",
"def create_elevator_list\n \n for elevatorID in 1..Column.num_elevators do\n elevator = Elevator.new(elevatorID)\n elevator.create_floor_buttons()\n @elevator_list.append(elevator)\n end\n end",
"def actions\n answer = @prompt.select(\"Where will you go?\", %w(Foward Back Status Items), cycle:true, per_page:4)\n if answer == \"Foward\"\n if @zone_cur == 10\n narrate(\"you leave the #{self.name}\")\n leave(self.exit_name)\n else\n @zone_cur += 1\n narrate(\"you continue foward\")\n encounter_check\n end\n elsif answer == \"Back\"\n if @zone_cur == 0\n narrate(\"you leave the #{self.name}\")\n leave(self.entrance_name)\n else\n @zone_cur -= 1\n narrate(\"you retreat backwards\")\n encounter_check\n end\n elsif answer == 'Status'\n narrate(\"#{@player.name} has #{@player.hp} hp, #{@player.attack} attack, and #{@player.defence} defence\")\n str = \"\"\n a = @player.equipment.map do |el|\n el.name\n end\n b = a.join(\", \")\n narrate(\"#{@player.name} has the following items equipped: #{b}\")\n here\n elsif answer == 'Items'\n answer = @prompt.select(\"Items Menu\", %w(Equip_item Look_item), cycle:true, per_page:4)\n if answer == 'Equip_item'\n #list inventory\n stuff = @player.items.map do |el|\n el.name\n end\n #select an item from inventory\n answer = @prompt.select(\"Items Menu\", stuff, cycle:true, per_page:4)\n #find that item again\n to_eq = @player.items.find do |el|\n el.name == answer\n end\n binding.pry\n #equip that item\n @player.equip(to_eq)\n narrate( \"You have equipped the #{to_eq.name}!\")\n actions\n end\n end\n end",
"def teacher_main_menu(teacher_user) \n self.line_break\n puts \"Please select a command:\".colorize(:light_blue), \"1: Return to Main Menu\".colorize(:cyan), \"2: Exit\".colorize(:cyan)\n self.line_break\n input = gets.chomp\n until input == \"1\" || input == \"2\"\n puts \"Invalid response. Please select a command:\".colorize(:yellow), \"1: Return to Main Menu\".colorize(:cyan), \"2: Exit\".colorize(:cyan)\n input = gets.chomp\n end\n if input == \"1\"\n self.teacher_tasks(teacher_user)\n elsif input == \"2\"\n puts \"Have a great day!\".colorize(:light_green)\n end\n end",
"def trail_options\n menu = [\"View All Trails\", \n \"Search for Trail\", \n \"Exit\"]\n system 'clear'\n puts \"------TRAILS------\"\n choice = @prompt.select(\"Which action would you like to take?\", menu)\n case choice\n when \"View All Trails\"\n print_trail_info(Trail.all)\n when \"Search for Trail\"\n search_for_trail(Trail.all)\n end\n @prompt.keypress(\"Press any key to continue\")\nend",
"def join\r\n if @trip.participants.include?(current_person)\r\n redirect_to(@trip, :notice => \"You are already a participant in the #{@trip.name}.\")\r\n return\r\n elsif @trip.organizers.include?(current_person) && request.post?\r\n @trip.participants << current_person\r\n redirect_to(manage_membership_trip_url(@trip), :notice => \"You are now a participant in the #{@trip.name}.\")\r\n else\r\n @token = params[:token]\r\n invitation = Invitation.find_by_token(@token)\r\n if invitation.nil?\r\n redirect_to(person_root_url, :error => \"The invitation link you followed is invalid.\")\r\n return\r\n end\r\n \r\n if request.post?\r\n invitation.accept(current_person)\r\n redirect_to(manage_membership_trip_url(@trip), :notice => \"You are now a participant in the #{@trip.name}.\")\r\n end\r\n end\r\n end",
"def leta_menu(name, &menu_proc)\n puts \"Hi Beloved Customer\"\n menu_proc.call(name)\nend",
"def stop_elevator\n return false if stops_remaining?\n @direction = 0 and return true\n end",
"def lease\n system \"clear\"\n puts \"Welcome to the lease generator\"\n puts \"What is your full name?\"\n user_name = gets.chomp.split(\" \").map(&:capitalize).join(\" \") #This capitalizes every word of the sentence\n puts \"Who are you leasing an apartment from?\"\n leaser_name = gets.chomp.split(\" \").map(&:capitalize).join(\" \")\n puts \"How long is the lease? (in months)?\"\n length_of_term = gets.chomp.to_i\n puts \"How much is rent per month?\"\n rent = gets.chomp.to_i\n puts\n puts \"Below is the lease agreement. Please sign at the end.\"\n puts \"The leaser #{user_name} will be renting the apartment from #{leaser_name} for #{length_of_term} months.\"\n puts \"The rate will be $#{rent} per month. On average this will cost $#{rent*length_of_term}\"\nend",
"def main_menu\n name_selector\n puts \"Okay #{@name}, what would you like to do?\"\n loop do\n case menu_arrows\n when '1'\n @recommendation.recommendation_menu\n when '2'\n puts 'you have the following number of games in your library: '\n @game_library.game_instances\n puts 'your custom list of games:'\n @game_library.user_games_lister\n when '3'\n puts 'add a game:'\n @game_library.add_title\n when '4'\n @game_library.delete_games\n when '5'\n @time_used.time_wasted\n when '6'\n @game_library.write_games\n puts 'thanks for your time!'\n exit\n end\n end\n end",
"def call_option(user_selected)\n case user_selected\n when 1 then add_new_contact\n when 2 then modify_existing_contact\n when 3 then delete_contact\n when 4 then display_all_contacts\n when 5 then search_by_attribute\n when 6 then exit\n end\n end",
"def log\n # When someone actually picks up the call\n if params[:DialAction] == 'answer'\n user_number = UserNumber.find_by_sip_endpoint(params[:DialBLegTo])\n @call.update! user_number: user_number\n # When the call is over, we log the call duration and the time it took to\n # pick up the call\n elsif params[:DialAction] == 'hangup' &&\n params[:DialBLegHangupCause] == 'NORMAL_CLEARING'\n pickup_time = params[:AnswerTime].to_time - params[:StartTime].to_time\n @call.update! duration: params[:DialBLegDuration], pickup_time: pickup_time\n end\n render nothing: true\n end",
"def elevator_incidents\n @elevator_incidents ||= ElevatorIncident.get_by_station(self)\n end",
"def take_ride\n enough_tickets, tall_enough = meet_requirements\n if enough_tickets && tall_enough\n start_ride\n elsif tall_enough && !enough_tickets\n \"Sorry. \" + ticket_warn\n elsif enough_tickets && !tall_enough\n \"Sorry. \" + height_warn\n else\n \"Sorry. \" + ticket_warn + \" \" + height_warn\n end\n end",
"def command_use_point\r\r\n if $game_actors[@actor.id].skill_tree[0] == 0 || confirm_skill_add\r\r\n Sound.play_buzzer\r\r\n @confirm.close\r\r\n @confirm.active = false\r\r\n else\r\r\n @skills_icons[@skill_selected].opacity = 255\r\r\n $game_actors[@actor.id].skill_tree[0] -= 1\r\r\n $game_actors[@actor.id].lose_jp(Actor[@actor.id][@skill_selected]['JP'])\r\r\n $game_actors[@actor.id].skill_mult[Actor[@actor.id][@skill_selected]['Skill_id']] += Actor[@actor.id][@skill_selected]['Multiply']\r\r\n $game_actors[@actor.id].skill_tree[Actor[@actor.id][@skill_selected]['Skill_id']] += 1\r\r\n $game_actors[@actor.id].learn_skill(Actor[@actor.id][@skill_selected]['Skill_id'])\r\r\n @info_window.refresh(@actor, @tree)\r\r\n Audio.se_play(\"Audio/SE/Skill3\",75,100)\r\r\n @confirm.close\r\r\n @confirm.active = false\r\r\n if $game_switches[19] # achievement available?\r\r\n #------------------------------------------------------------------------------- \r\r\n # Trophic: Markspony\r\r\n #-------------------------------------------------------------------------------\r\r\n earn_trophic = true\r\r\n for i in 546..561\r\r\n if !$game_actors[@actor.id].skill_learned?(i) && !$ACH_markspony\r\r\n earn_trophic = false\r\r\n break\r\r\n end\r\r\n end\r\r\n \r\r\n if earn_trophic && !$ACH_markspony\r\r\n $ACH_markspony = true\r\r\n GameJolt.award_trophy(\"53491\")\r\r\n p sprintf(\"Achievement unlock - markspony\")\r\r\n $game_system.earn_achievement(:markspony)\r\r\n end\r\r\n #------------------------------------------------------------------------------- \r\r\n # Trophic: Elementalist\r\r\n #------------------------------------------------------------------------------- \r\r\n earn_trophic = true\r\r\n for i in 563..582\r\r\n next if i == 567 || i == 571 || i == 577 || i == 581 \r\r\n if !$game_actors[@actor.id].skill_learned?(i) && !$ACH_elementalist\r\r\n earn_trophic = false\r\r\n break\r\r\n end\r\r\n end\r\r\n \r\r\n if earn_trophic && !$ACH_elementalist\r\r\n $ACH_elementalist = true\r\r\n GameJolt.award_trophy(\"53485\") \r\r\n p sprintf(\"Achievement unlock - elementalist\")\r\r\n $game_system.earn_achievement(:elementalist)\r\r\n end\r\r\n #---------------------------------------------------\r\r\n end\r\r\n end\r\r\n end",
"def level_to_agent\r\n Admin.to_agent params[:id]\r\n redirect_to :action => 'show_agents' \r\n end",
"def game_menu(user, game, tracer=2)\n choose_game(user) if !game\n reviews = Review.where(game_id: game.id)\n avg_rating = reviews.count == 0 ? \" --- \" : (reviews.sum(:rating).to_f / reviews.count).round(2)\n myrev = nil\n myrev = reviews.find_by(user_id: user.id) if user != \"guest\"\n myrev ? myrev = myrev.id * 100 : myrev = 2\n router = nil\n message = []\n # base options\n options = [\n [\"Read Reviews\", 9],\n [\"Write a Review\", 10],\n [\"Read My Review\", myrev],\n [\"Update My Review\", 11],\n [\"My Reviewed Games\", 13],\n [\"Choose Another Game\", 8],\n [\"Log In\", 3],\n [\"Previous Menu\", tracer],\n [\"Main Menu\", 2],\n [\"Exit\", 1]\n ]\n # removing options based on status\n if user == \"guest\"\n options.delete_at(4)\n options.delete_at(3)\n options.delete_at(2)\n options.delete_at(1)\n elsif myrev > 99\n options.delete_at(6)\n options.delete_at(1)\n elsif !Review.find_by(user_id: user.id)\n options.delete_at(6)\n options.delete_at(4)\n options.delete_at(3)\n options.delete_at(2)\n else\n options.delete_at(6)\n options.delete_at(3)\n options.delete_at(2)\n end\n options.delete_at(0) if reviews.count == 0\n # display loop until validated choice\n until router\n display_menu_header([\"#{game.name}:\", \"Release Date: #{Time.at(game.release_date.to_i).strftime('%m/%d/%Y')}\", \"Average GR Rating: #{avg_rating} (based on #{reviews.count} ratings)\", \"Average IGDB Rating: #{game.igdb_rating.round(2)} (based on #{game.igdb_rating_count} ratings)\"], user)\n router = display_options_menu(options, message)\n message = [\"Sorry, invalid selection. Please choose again...\"]\n end\n menu_routing(user, game, router, 15)\nend",
"def superhero_choosen?\n\n if self.user.superheros.empty?\n puts \"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\"\n puts \"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\"\n puts\"\n \n ██████╗ ██████╗ ██████╗ ██████╗ ██████╗ ██████╗ ███████╗██╗\n ██╔═══██╗██╔═══██╗██╔═══██╗██╔═══██╗██╔═══██╗██╔══██╗██╔════╝██║\n ██║ ██║██║ ██║██║ ██║██║ ██║██║ ██║██████╔╝███████╗██║\n ██║ ██║██║ ██║██║ ██║██║ ██║██║ ██║██╔═══╝ ╚════██║╚═╝\n ╚██████╔╝╚██████╔╝╚██████╔╝╚██████╔╝╚██████╔╝██║ ███████║██╗\n ╚═════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚═╝ ╚══════╝╚═╝\n \n \n \".colorize(:red)\n \n puts \"\\n\\nYou have no Superheros yet! Select option 2 in main menu!\"\n \n \n sleep 3\n self.main_menu()\n end\n end",
"def menu\n puts \"EEG query app\"\n puts \"1: return EEG value\"\n puts \"2: return attention value\"\n puts \"3: return meditation value\"\n gets.chomp\nend",
"def livingRoomVisit(inputTime, lrFunc, source, destination)\n\n\t#puts \"inputTime in lrVisit: \" + inputTime.inspect\n\tinputTime = houseTrip(inputTime, source, $tagID_lr)\n\n\tif lrFunc == 1\n\t\tinputTime += $minute*15 + rand($minute*15)\n\telsif lrFunc == 2\n\t\tinputTime += 30*$minute + rand($minute*30)\n\telsif lrFunc == 3\n\t\tinputTime += 60*$minute + rand($hour*2)\n\tend\n\n\t#exit bathroom, another hallwayscan after random amount of time in bath ( ~5min)\n\t#puts \"At return --->>>> inputTime: \" + inputTime.strftime(\"%I:%M:%S%p %m/%d/%y\")\n\t#puts \"Now going from \" + $tagID_bathroom1 + \" to \" + destination\n\t#inputTime = \n\t#puts \"inputTime after LR chillin: \" + inputTime.inspect\n\treturn houseTrip(inputTime, $tagID_lr, destination)\nend",
"def explore_room \n if encounterCallee(:bats) && @@setBatTrap\n @@blockEncounters[1].call() \n @@setBatTrap=false\n end\n #Sensing \n if senseCallee(:bats)\n @@blockSenses[0].call()\n end\n if senseCallee(:guard)\n @@blockSenses[1].call()\n end\n if senseCallee(:pit)\n @@blockSenses[2].call()\n end \n end",
"def ask\n @prompt.select \"Would you like to schedule appointment now\" do |menu|\n menu.choice \" Yes\", -> { schedule_appointment }\n menu.choice \" No <Go Back>\", -> { appointment_system }\n end\n end",
"def restaurant\n end",
"def intake_guest\n #@intake.post\n end",
"def offer\n loc = @item.location || @item.zone\n @engine.push_context(\"offered_action\" => @action_name, \"offered_location\" => loc.name, \"offering_item\" => @item.name) do\n loc.receive_offer(@action_name, self)\n end\n end"
] |
[
"0.7893657",
"0.6704976",
"0.66869915",
"0.6633177",
"0.6372739",
"0.62872225",
"0.60688555",
"0.6042272",
"0.6025063",
"0.60061514",
"0.59596217",
"0.5956157",
"0.58742386",
"0.58642185",
"0.5857096",
"0.58437794",
"0.5784931",
"0.5744474",
"0.5700002",
"0.56890196",
"0.5662407",
"0.5661084",
"0.5611782",
"0.56042314",
"0.55808026",
"0.55490845",
"0.54848486",
"0.54802334",
"0.547736",
"0.5420294",
"0.53652346",
"0.53381413",
"0.532679",
"0.5315996",
"0.5308536",
"0.526612",
"0.5261725",
"0.5259242",
"0.5231938",
"0.5222415",
"0.51918507",
"0.5171921",
"0.5159591",
"0.5149638",
"0.51415825",
"0.51291",
"0.5118337",
"0.51078033",
"0.5098985",
"0.50915164",
"0.5087337",
"0.50869983",
"0.50737643",
"0.50611216",
"0.505686",
"0.5044652",
"0.50274324",
"0.50164324",
"0.49967444",
"0.49570173",
"0.49512988",
"0.4937061",
"0.49222356",
"0.49208677",
"0.49193016",
"0.4918509",
"0.4909713",
"0.4900062",
"0.489756",
"0.48973915",
"0.48843333",
"0.48834977",
"0.48810336",
"0.48426446",
"0.48394877",
"0.48339316",
"0.4828164",
"0.48254517",
"0.48237672",
"0.48179555",
"0.4817756",
"0.48172015",
"0.48141548",
"0.4813378",
"0.48119497",
"0.48025718",
"0.48018187",
"0.47995585",
"0.47985262",
"0.47977898",
"0.4792815",
"0.4789778",
"0.4772074",
"0.4764825",
"0.4763783",
"0.47584173",
"0.47550204",
"0.47548237",
"0.4751314",
"0.47479853"
] |
0.66954315
|
2
|
Comparing elevator to previous best
|
def checkBestElevator(scoreToCheck, newElevator, bestElevatorInfo, floor)
#If elevators situation is more favourable
if scoreToCheck < bestElevatorInfo[1]
bestElevatorInfo[1] = scoreToCheck
bestElevatorInfo[0] = newElevator
bestElevatorInfo[2] = (newElevator.elevatorCurrentFloor - floor).abs
#If elevators are in a similar situation, set the closest one to the best elevator
elsif bestElevatorInfo[1] == scoreToCheck
gap = (newElevator.elevatorCurrentFloor - floor).abs
if bestElevatorInfo[2] > gap
bestElevatorInfo[1] = scoreToCheck
bestElevatorInfo[0] = newElevator
bestElevatorInfo[2] = gap
end
end
return bestElevatorInfo
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def choose_elevator\n elevator_scores = []\n\n for elevator in @column.elevator_list do\n \n # Initialize score to 0\n score = 0\n floor_difference = elevator.current_floor - @floor\n\n # Prevents use of any offline/under-maintenance elevators\n if elevator.status != \"online\"\n score = -1\n elevator_scores.append(score)\n else\n\n # Bonify score based on difference in floors\n if floor_difference == 0\n score += 5000\n else\n score += 5000/(floor_difference.abs() + 1)\n end\n \n # Bonify score based on direction (highest priority)\n if elevator.movement != \"idle\"\n if floor_difference >= 0 and @direction == \"down\" and elevator.movement == \"down\"\n \n # Paths are crossed going down, therefore favor this elevator\n score += 10000\n \n elsif floor_difference <= 0 and @direction == \"up\" and elevator.movement == \"up\"\n\n # Paths are crossed going down, therefore favor this elevator\n score += 10000\n \n else\n \n # Paths are not crossed, therefore try avoiding the use of this elevator\n score = 0\n \n # Give redemption points, in worst case scenario where all elevators never cross paths\n next_floor_difference = elevator.next_floor - @floor\n if next_floor_difference == 0\n score += 500\n else\n score += 500/(next_floor_difference.abs() + 1)\n end\n end\n end\n\n # Bonify score on request queue size (the smaller number of pre-existing requests, the faster therefore the better)\n if elevator.requests_queue.length() <= 3\n score += 1000\n elsif elevator.requests_queue.length() <= 7\n score += 250\n end\n \n # Send total score of elevator to the scores list\n elevator_scores.append(score)\n end\n end\n\n # Get value of highest score\n highest_score = -1\n for score in elevator_scores do\n if (score > highest_score)\n highest_score = score\n end\n end\n \n # Get elevator with the highest score (or nil if all elevators were offline\n chosen_elevator = nil\n if (highest_score > -1)\n chosen_elevator = @column.elevator_list[elevator_scores.find_index(highest_score)]\n puts \"Chosen elevator: Elevator #{chosen_elevator.id}\"\n end\n return chosen_elevator\n end",
"def findNearestElevator(currentFloor, selectedList)\n bestElevator = selectedList[0]\n bestDistance = (selectedList[0].floor - currentFloor).abs #abs() returns the absolute value of a number (always positive).\n \n for elevator in selectedList\n if (elevator.floor - currentFloor).abs < bestDistance\n bestElevator = elevator\n end\n end\n \n puts \"\"\n puts \" >> >>> ELEVATOR #{bestElevator.id} WAS CALLED <<< <<\"\n return bestElevator\n end",
"def elevator\n elevators.sort_by { |e| e.stop_count }.first\n end",
"def update_best\n if @best_price < @ep.max\n @best_price = @ep.max\n res_i = @ep.index(@best_price)\n @best_weight = @bw[res_i]\n @best_baggage = in_bag(@cg[res_i])\n end\n end",
"def find_optimal(rootCode,goalCode)\n\tfindHops(rootCode, goalCode, \n\t\tlambda{|flight,oldweight| \n\t\t\toldweight + (flight.date.date.to_i + (flight.flightDuration).seconds - @date.date.to_i)/1200 + 100 + flight.seatprice/5 \n\t\t\t# oldweight + (number of hours between arrival and departure + 100 (per hop))*3 + seatprice/5 (~25-250)\n\t\t\t})\nend",
"def improve_teams\n @teams = steepest_ascent_hill(@teams)\n end",
"def best_tipper\n best_tipped_meal = meals.max do |meal_a, meal_b|\n meal_a.tip <=> meal_b.tip\n end \n best_tipped_meal.customer\n end",
"def bottoms_up_method\n\t\t# 1. take the nodes that went the farthest (i.e.: max tree level)\n\t\tmax_level = @tree.tree_bottom.collect(&:level).max\n\t\t# 2. Of those, use the one with the minimum sum value\n\t\twinner = @tree.tree_bottom.select{|t|t.level==max_level}.min_by(&:sum)\n\t\t# binding.pry \n\t\tbottoms_up_dir(winner).dir\n\tend",
"def determine_winner\n @active_players.sort! do |player1, player2|\n if player1.strongest_hand > player2.strongest_hand\n -1\n elsif player1.strongest_hand < player2.strongest_hand\n 1\n else\n 0\n end\n end\nend",
"def worst_offense\n teams_total_goals = total_goals_helper\n teams_total_games = total_games_helper\n\n worst_team_goals_avg = 1000\n worst_offense_team_id = 0\n this_team_goals_avg = 0\n\n teams_total_games.each do |games_key, games_value|\n teams_total_goals.each do |goals_key, goals_value|\n if goals_key == games_key\n this_team_goals_avg = (goals_value / games_value.to_f)\n if this_team_goals_avg < worst_team_goals_avg\n worst_team_goals_avg = this_team_goals_avg\n worst_offense_team_id = games_key\n end\n end\n end\n end\n\n team_with_worst_offense = nil\n self.teams.each_value do |team_obj|\n if team_obj.team_id. == worst_offense_team_id\n team_with_worst_offense = team_obj.team_name\n end\n end\n team_with_worst_offense\n end",
"def find_nearest_elevator(elevator_direction, request_location)\n elevators = find_elevators_by_direction(elevator_direction)\n elevators.each { |elevator| elevator.distance_score = (request_location - elevator.current_floor).abs }\n return elevators.min { |a, b| a.distance_score <=> b.distance_score }\n end",
"def smallest_team\n self.teams.min{|t1,t2| t1.runners.size <=> t2.runners.size }\n end",
"def findElevator(currentFloor, direction)\n activeElevatorList = []\n idleElevatorList = []\n sameDirectionElevatorList = []\n for x in @elevatorsList\n if x.status != ElevatorStatus::IDLE #verify if elevator is active and if the request is on the elevator way\n if x.status == ElevatorStatus::UP and x.floor <= currentFloor or x.status == ElevatorStatus::DOWN and x.floor >= currentFloor\n activeElevatorList.append(x)\n end\n else\n idleElevatorList.append(x)\n end\n end\n\n if activeElevatorList.length > 0 #Create new list for elevators with same direction that the request\n sameDirectionElevatorList = activeElevatorList.select {|elevator| elevator.status == direction}\n end\n \n if sameDirectionElevatorList.length > 0\n bestElevator = findNearestElevator(currentFloor, sameDirectionElevatorList)\n else\n bestElevator = findNearestElevator(currentFloor, idleElevatorList)\n end\n \n return bestElevator\n end",
"def best_tipper\n best_tipped_meal = meals.max do |meal_a, meal_b|\n meal_a.tip <=> meal_b.tip\n end\n \n best_tipped_meal.customer\n end",
"def lowest_scoring_visitor\n @teams.min_by { |team| team.average_away_goals }.team_name\n end",
"def best_laps\n best_laps = []\n RACER_RECORDS.each {|racer| best_laps << [ racer.piloto, racer.best_lap ]}\n @view.display_best_laps(best_laps)\n end",
"def next_league(leagues)\n floodgate = leagues.min {|a,b| a.next_time <=> b.next_time}\n return floodgate\n end",
"def best_tipper\n meal_with_highest_tip = meals.max do |meal_a, meal_b|\n meal_a.tip <=> meal_b.tip\n end\n\n meal_with_highest_tip.customer \n end",
"def best_tipper\n best_tipped_meal = meals.max do |meal_a, meal_b|\n meal_a.tip <=> meal_b.tip\n end\n\n best_tipped_meal.customer\n end",
"def update_p_best\r\n return unless @fitness > p_best_fitness\r\n\r\n @p_best_fitness = @fitness\r\n @p_best_position = @position\r\n end",
"def best_tipper\n best_tipped_meal = meals.max do | meal_a, meal_b |\n meal_a.tip <=> meal_b.tip\n end\n best_tipped_meal.customer\n end",
"def best_solution\n # Sort existing solutions by expected makespan.\n @solutions.sort_by!(&:expected_makespan)\n # First solution is the best one.\n @solutions.first\n end",
"def user_in_top_of_ladder(ladder)\n user_score_index = ladder.index(self)\n\n while user_score_index - 1 >= 0\n previous = ladder[user_score_index - 1]\n if (previous.pushes > self.pushes) or (previous.pushes == self.pushes and previous.moves >= self.moves)\n ladder[user_score_index - 1], ladder[user_score_index] = ladder[user_score_index], ladder[user_score_index - 1]\n user_score_index = user_score_index - 1\n else\n break\n end\n end\n\n return user_score_index\n end",
"def find_closest_eligible_elevator(requested_direction, requested_floor)\n closest_eligible_elevator = elevators_sorted_by_call_proximity(requested_floor).detect do |e|\n e.eligible_for_pickup?(requested_direction, requested_floor)\n end\n if closest_eligible_elevator\n closest_eligible_elevator\n else\n find_closest_eligible_elevator(requested_direction, requested_floor)\n end\n end",
"def compute_team_winner\n if completed?\n team_winner\n else\n if first_team && second_team\n if sets_won(first_team) == min_sets_to_play\n first_team\n elsif sets_won(second_team) == min_sets_to_play\n second_team\n end\n end\n end\n end",
"def best_defense\n teams_total_goals_allowed = total_goals_allowed_helper\n teams_total_games = total_games_helper\n\n best_team_goals_allowed_avg = 100\n best_defense_team_id = 0\n this_team_goals_allowed_avg = 0\n\n teams_total_games.each do |games_key, games_value|\n teams_total_goals_allowed.each do |goals_key, goals_value|\n if goals_key == games_key\n this_team_goals_allowed_avg = (goals_value / games_value.to_f)\n if this_team_goals_allowed_avg < best_team_goals_allowed_avg\n best_team_goals_allowed_avg = this_team_goals_allowed_avg\n best_defense_team_id = games_key\n end\n end\n end\n end\n\n team_with_best_defense = nil\n self.teams.each_value do |team_obj|\n if team_obj.team_id. == best_defense_team_id\n team_with_best_defense = team_obj.team_name\n end\n end\n team_with_best_defense\n end",
"def find_best_move(brd)\n\n # Shortcircuit first move so 5 is always choosen\n return 5 if empty_squares(brd).count == 9\n\n\n best_val = -INFINITY\n best_move = nil\n\n brd.each do |cell, status|\n if status == INITIAL_MARKER\n brd[cell] = COMPUTER_MARKER\n move_val = minimax(brd, 0, 'player')\n brd[cell] = INITIAL_MARKER\n if move_val > best_val\n best_val = move_val\n best_move = cell\n end\n end\n end\n return best_move\n end",
"def best_move(good_moves)\n best_move = good_moves.sample\n good_moves.each do |move|\n if @board.piece_at(move.last).value >\n @board.piece_at(best_move.last).value\n best_move = move\n end\n end\n best_move\n end",
"def most_money(rideshare)\n highest_earned = 0.0\n high_earner = \"\"\n # call method from #2\n money_made(rideshare).map do |driver, cost|\n if cost > highest_earned\n highest_earned = cost\n high_earner = driver\n end\n end\n return high_earner\nend",
"def take_best\n roll_all.max\n end",
"def best_picks\n self.picks.sort_by{|pick| pick.points}.reverse!.first(5)\n end",
"def calculate_computers_move\n available_squares.zip(next_scores).sort_by { |key, value| value }.reverse.first.first\n end",
"def get_best_rated(drivers)\n best_rated = nil\n best_avg = 0\n drivers.each do |driver, rides|\n current_avg = get_avg_rating(rides)\n if best_avg < current_avg\n best_rated = driver\n best_avg = current_avg\n end\n end\n return best_rated\nend",
"def request_this_elevator()\n self.set_direction\n self.status_update\n case self.direction\n when 0\n self.set_direction\n when 1\n if self.current_floor == self.up_queue[0]\n self.up_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor + 1\n\n if self.up_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n when -1\n if self.current_floor == self.down_queue[0]\n self.down_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor - 1\n if self.down_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n end\n end",
"def winning_team\n final_scores = player_collection.reduce(home: 0, away: 0) { |teams_points, next_player|\n case \n when next_player[:location] === :away\n teams_points[:away] += next_player[:points];\n when next_player[:location] === :home\n teams_points[:home] += next_player[:points];\n end\n teams_points; \n }\n winner = final_scores.reduce { |highest_points, team_points| \n highest_points[1] > team_points[1] ? highest_points : team_points; \n }\n game_hash[winner[0]][:team_name]; \nend",
"def compare_eflh(runner, old_sch, new_sch)\n \n if old_sch.to_ScheduleRuleset.is_initialized\n old_sch = old_sch.to_ScheduleRuleset.get\n elsif old_sch.to_ScheduleConstant.is_initialized\n old_sch = old_sch.to_ScheduleConstant.get\n else\n runner.registerWarning(\"Can only calculate equivalent full load hours for ScheduleRuleset or ScheduleConstant schedules. #{old_sch.name} is neither.\")\n return false\n end\n\n if new_sch.to_ScheduleRuleset.is_initialized\n new_sch = new_sch.to_ScheduleRuleset.get\n elsif new_sch.to_ScheduleConstant.is_initialized\n new_sch = new_sch.to_ScheduleConstant.get\n else\n runner.registerWarning(\"Can only calculate equivalent full load hours for ScheduleRuleset or ScheduleConstant schedules. #{new_sch.name} is neither.\")\n return false\n end \n \n new_eflh = new_sch.annual_equivalent_full_load_hrs\n old_eflh = old_sch.annual_equivalent_full_load_hrs\n if new_eflh < old_eflh\n runner.registerInfo(\"The new occupancy-tracking HVAC operation schedule, #{new_sch.name} (#{new_eflh.round} EFLH) is more aggressive than the existing schedule #{old_sch.name} (#{old_eflh.round} EFLH).\")\n return true\n elsif new_eflh == old_eflh\n runner.registerWarning(\"The existing HVAC operation schedule, #{old_sch.name} (#{old_eflh.round} EFLH), is equally as aggressive as the new occupancy-tracking schedule #{new_sch.name} (#{new_eflh.round} EFLH). Not applying new schedule.\")\n return false \n elsif\n runner.registerWarning(\"The existing HVAC operation schedule, #{old_sch.name} (#{old_eflh.round} EFLH), is more aggressive than the new occupancy-tracking schedule #{new_sch.name} (#{new_eflh.round} EFLH). Not applying new schedule.\")\n return false\n end\n \n end",
"def winner\n if (self.homeScore > self.awayScore)\n return self.home_team\n elsif (self.awayScore > self.homeScore)\n return self.away_team\n else\n return nil\n end\n end",
"def heuristic_solving_possible\n prev_item = nil\n items.each do |item|\n if prev_item.present?\n if item[:c] < prev_item[:c]\n # \"The absolute cost of a heavier item (cost #{item[:c]} with weight #{item[:w]}) is lower than the cost of another item (cost #{prev_item[:c]} with weight #{prev_item[:w]})\"\n return false\n elsif (item[:c].to_f / item[:w].to_f) > (prev_item[:c].to_f / prev_item[:w].to_f)\n # \"The relative cost of a heavier item (cost #{item[:c]} with weight #{item[:w]} having a relative cost of #{item[:c].to_f/item[:w].to_f}) is higher than the cost of another item (cost #{prev_item[:c]} with weight #{prev_item[:w]} having a relative cost of #{prev_item[:c].to_f/prev_item[:w].to_f})\"\n return false\n end\n end\n prev_item = item\n end\n true\n end",
"def compare_by_points(other, break_ties = true)\n diff = other.points <=> points\n return diff if diff != 0 || !break_ties\n\n diff = compare_by_highest_place(other)\n return diff if diff != 0\n\n diff = compare_by_most_recent_place(other)\n return diff if diff != 0\n\n 0\n end",
"def biggest_blowout\n score_difference = games.map { |game| (game.home_goals - game.away_goals).abs}\n score_difference.max\n end",
"def best_lap\n best_lap = []\n self.voltas.each { |lap_num, lap_stat| best_lap << [lap_num, lap_stat] }\n best_lap.sort! {|x,y| x[1][:tempo] <=> y[1][:tempo]}\n best_lap = best_lap[0]\n return best_lap\n end",
"def runoff(voters)\n\n def find_winner(voters, tallies=nil)\n if tallies\n min = tallies.values.min\n tallies.keep_if { |candidate, v| v == min }\n voters.each { |voter| voter.reject! {|vote| tallies.include? vote }}\n return nil if voters.length == 0\n end\n new_tallies = Hash.new(0)\n voters[0].each {|candidate| new_tallies[candidate] = 0 }\n voters.each_with_object(new_tallies) { |voter, nt| nt[voter[0]] += 1 }\n total_votes = new_tallies.values.reduce(:+);\n new_tallies.each { |candidate, v|\n return candidate if v / total_votes.to_f > 0.5\n }\n return find_winner(voters, new_tallies)\n end\n\n find_winner(voters)\n\nend",
"def identify_best_state\n best = EightQueens::NullState.new\n found_best_state = false\n\n @state.generate_successors do |successor|\n best = successor if best.friendly_pairs < successor.friendly_pairs\n found_best_state = true\n end\n\n found_best_state ? best : @state\n end",
"def price_is_right(bids, actual_retail_price)\n diff = actual_retail_price\n best_bid = nil\n bids.each do |bid|\n\n highest = actual_retail_price - bid\n\n if highest > 0 && highest <= diff\n diff, best_bid = highest, bid\n end\n end\n\n best_bid\nend",
"def calculate_top_event\n #this isn't the logic we're going to settle on -- just placeholder code for now\n\n return if self.events.where(:status.in => Event::TRENDED_OR_TRENDING).count == 0\n\n top_event = self.events.where(:status.in => Event::TRENDED_OR_TRENDING).order_by([[:end_time, :desc]]).first\n self.top_event_id = top_event.id\n self.top_event_score = top_event.get_adjusted_score\n end",
"def best_defense\n @teams.min_by { |team| team.average_goals_allowed }.team_name\n end",
"def getSurroundingLowestElevations(parent)\n\t\tx = parent.x\n\t\ty = parent.y\n\t\tcost = 0\n\t\tmin = nil\n\t\twaterFound = false\n\t\twater = nil\n\t\tmin_list = Array.new\n\t\t\n\t\t#search nodes around parent node\n\t\tfor i in (x-1..x+1)\n\t\t\tfor j in (y-1..y+1)\n\t\t\t\t#if its not the parent node\n\t\t\t\tif (i != x or j != y)\n\t\t\t\t\ttemp = @map[check_xy(i)][check_xy(j)]\n\t\t\t\t\t\n\t\t\t\t\t#if we've managed to find the ocean or some other water\n\t\t\t\t\tif temp.type != \"Land\"\n\t\t\t\t\t\twaterFound = true\n\t\t\t\t\t\twater = @river_struct.new parent, check_xy(i), check_xy(j), find_angle(parent, check_xy(i), check_xy(j)), parent.ttd-1\n\t\t\t\t\telsif (temp.elevation != -1 and temp.type == \"Land\")\n\t\t\t\t\t\tif min == nil or temp.elevation < @map[min.x][min.y].elevation\n\t\t\t\t\t\t\tmin_list.clear\n\t\t\t\t\t\t\tmin = @river_struct.new parent, check_xy(i), check_xy(j), find_angle(parent, check_xy(i), check_xy(j)), parent.ttd-1\n\t\t\t\t\t\t\tmin_list.push(min)\n\t\t\t\t\t\telsif temp.elevation == @map[min.x][min.y].elevation\n\t\t\t\t\t\t\tmin_list.push(@river_struct.new parent, check_xy(i), check_xy(j), find_angle(parent, check_xy(i), check_xy(j)), parent.ttd-1)\n\t\t\t\t\t\tend\n\t\t\t\t\t\t\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\t\t#if water has been found clear other options and use that node\n\t\tif waterFound\n\t\t\tmin_list.clear\n\t\t\tmin_list.push(water)\n\t\tend\n\t\t\n\t\treturn min_list\n\t\t\n\tend",
"def worst_offense\n @teams.min_by { |team| team.average_goals_scored }.team_name\n end",
"def set_ponderated_best\n total_time = 0\n result_considered = 0\n result_collected = @best_results.count\n everage_time = 0\n\n # If no results, no action performed\n if result_collected > 0\n # If total best results collected >= (bests_to_be_ignored + max_results)\n # excludes first @bests_to_be_ignored results\n if result_collected >= (@bests_to_be_ignored + @max_results)\n @best_results.each_with_index do |mir, index|\n total_time += mir.get_timing_instance.to_hundreds if index >= @bests_to_be_ignored\n end\n result_considered = @max_results\n else\n @best_results.each do |mir|\n total_time += mir.get_timing_instance.to_hundreds\n end\n result_considered = result_collected\n end\n everage_time = (total_time / result_considered).round(0)\n end\n @ponderated_time = Timing.new(everage_time)\n end",
"def houseRobber(arr)\n \toldBest = 0\n \tnewBest = 0\n \tsteal = 0\n\n \tfor loot in arr\n \t\tsteal = loot + oldBest\n \t\toldBest = newBest\n \t\tnewBest = [steal,oldBest].max \n \tend\n \n return newBest\nend",
"def next_elevator\n strategies.map { |strategy| strategy.elevator(elevators, request) }.first\n end",
"def best_fans\n @teams.max_by { |team| team.home_minus_away_percentage }.team_name\n end",
"def compare_eflh(runner, old_sch, new_sch)\n if old_sch.to_ScheduleRuleset.is_initialized\n old_sch = old_sch.to_ScheduleRuleset.get\n elsif old_sch.to_ScheduleConstant.is_initialized\n old_sch = old_sch.to_ScheduleConstant.get\n else\n runner.registerWarning(\"Can only calculate equivalent full load hours for ScheduleRuleset or ScheduleConstant schedules. #{old_sch.name} is neither.\")\n return false\n end\n\n if new_sch.to_ScheduleRuleset.is_initialized\n new_sch = new_sch.to_ScheduleRuleset.get\n elsif new_sch.to_ScheduleConstant.is_initialized\n new_sch = new_sch.to_ScheduleConstant.get\n else\n runner.registerWarning(\"Can only calculate equivalent full load hours for ScheduleRuleset or ScheduleConstant schedules. #{new_sch.name} is neither.\")\n return false\n end\n\n new_eflh = new_sch.annual_equivalent_full_load_hrs\n old_eflh = old_sch.annual_equivalent_full_load_hrs\n if new_eflh < old_eflh\n runner.registerInfo(\"The new exhaust fan schedule, #{new_sch.name} (#{new_eflh.round} EFLH) is more aggressive than the existing schedule #{old_sch.name} (#{old_eflh.round} EFLH).\")\n return true\n elsif new_eflh == old_eflh\n runner.registerWarning(\"The existing exhaust fan schedule, #{old_sch.name} (#{old_eflh.round} EFLH), is equally as aggressive as the new occupancy-tracking schedule #{new_sch.name} (#{new_eflh.round} EFLH). Not applying new schedule.\")\n return false\n elsif\n runner.registerWarning(\"The existing exhaust fan schedule, #{old_sch.name} (#{old_eflh.round} EFLH), is more aggressive than the new occupancy-tracking schedule #{new_sch.name} (#{new_eflh.round} EFLH). Not applying new schedule.\")\n return false\n end\n end",
"def compare_eflh(runner, old_sch, new_sch)\n if old_sch.to_ScheduleRuleset.is_initialized\n old_sch = old_sch.to_ScheduleRuleset.get\n elsif old_sch.to_ScheduleConstant.is_initialized\n old_sch = old_sch.to_ScheduleConstant.get\n else\n runner.registerWarning(\"Can only calculate equivalent full load hours for ScheduleRuleset or ScheduleConstant schedules. #{old_sch.name} is neither.\")\n return false\n end\n\n if new_sch.to_ScheduleRuleset.is_initialized\n new_sch = new_sch.to_ScheduleRuleset.get\n elsif new_sch.to_ScheduleConstant.is_initialized\n new_sch = new_sch.to_ScheduleConstant.get\n else\n runner.registerWarning(\"Can only calculate equivalent full load hours for ScheduleRuleset or ScheduleConstant schedules. #{new_sch.name} is neither.\")\n return false\n end\n\n new_eflh = new_sch.annual_equivalent_full_load_hrs\n old_eflh = old_sch.annual_equivalent_full_load_hrs\n if new_eflh < old_eflh\n runner.registerInfo(\"The new exhaust fan schedule, #{new_sch.name} (#{new_eflh.round} EFLH) is more aggressive than the existing schedule #{old_sch.name} (#{old_eflh.round} EFLH).\")\n return true\n elsif new_eflh == old_eflh\n runner.registerWarning(\"The existing exhaust fan schedule, #{old_sch.name} (#{old_eflh.round} EFLH), is equally as aggressive as the new occupancy-tracking schedule #{new_sch.name} (#{new_eflh.round} EFLH). Not applying new schedule.\")\n return false\n elsif\n runner.registerWarning(\"The existing exhaust fan schedule, #{old_sch.name} (#{old_eflh.round} EFLH), is more aggressive than the new occupancy-tracking schedule #{new_sch.name} (#{new_eflh.round} EFLH). Not applying new schedule.\")\n return false\n end\n end",
"def best_time(event)\n registrant_best_times.find_by(event: event) || registrant_choices.joins(:event_choice).merge(EventChoice.where(cell_type: \"best_time\", event: event)).first\n end",
"def best_move_for(player)\n return minimax(player)[1]\n end",
"def check_for_optimal_move(mark_value)\n @board.all_valid_moves.each do |valid_move|\n @board.mark_square(valid_move[0],valid_move[1],mark_value)\n marked_square=[valid_move[0],valid_move[1]]\n if @board.winner?\n return mark_value\n elsif @board.tie?\n return 0\n else\n check_for_optimal_move(mark_value = -mark_value)\n end\n end\nend",
"def cheapest_price\n # CARYN SAYS: this should be cheapest restaurant! \n Recipe.all.min { |recipe_a, recipe_b| recipe_a.average_price <=> recipe_b.average_price }\n end",
"def worst_defense\n teams_total_goals_allowed = total_goals_allowed_helper\n teams_total_games = total_games_helper\n\n worst_team_goals_allowed_avg = 0\n worst_defense_team_id = 0\n this_team_goals_allowed_avg = 0\n\n teams_total_games.each do |games_key, games_value|\n\n teams_total_goals_allowed.each do |goals_key, goals_value|\n if goals_key == games_key\n this_team_goals_allowed_avg = (goals_value / games_value.to_f)\n if this_team_goals_allowed_avg > worst_team_goals_allowed_avg\n worst_team_goals_allowed_avg = this_team_goals_allowed_avg\n worst_defense_team_id = games_key\n end\n end\n end\n end\n team_with_worst_defense = team_name_finder_helper(worst_defense_team_id)\n\n team_with_worst_defense\n end",
"def find_elevators_by_direction(elevator_direction)\n same_direction = @elevator_list.select { |elevator| elevator.direction == elevator_direction }\n idle = @elevator_list.select { |elevator| elevator.direction.zero? }\n if same_direction.length > 0\n return same_direction\n else\n return idle\n end\n end",
"def best_strategy(state)\n build_best(state.pile_size)\n puts \"Good states=#{@good_states}\"\n tgts = targets(state.pile_size)\n tgts.each do |tg|\n op = state.op_to(tg, @ops) \n return op if op\n end\n nil\n end",
"def compute_best\n best = @population.max_by { |x| x.fitness(@target) }\n @finished = true if best.fitness(@target) == @perfect_score\n best.phrase\n end",
"def compute_best\n best = @population.max_by { |x| x.fitness(@target) }\n @finished = true if best.fitness(@target) == @perfect_score\n best.phrase\n end",
"def price_is_right(bids, actual_retail_price)\n\n best_bid = nil\n smallest_diff = nil\n\n bids.each do |bid|\n diff = actual_retail_price - bid\n\n if diff > 0\n if best_bid == nil or smallest_diff > diff\n smallest_diff = diff\n best_bid = bid\n end\n end\n end\n best_bid\nend",
"def best_answer\n\n answer = self.answers.order('up - down DESC').first\n\n #verifica se melhor resposta tem algum voto\n #se nao houver nenhum voto nao fica como melhor resposta\n if !answer.nil? && (( answer.up == 0 && answer.down == 0) || self.answers.first == answer || self.answers.count == 1 )\n answer = nil\n end\n\n return answer\n end",
"def leaster_winner\n players.inject(players.first) do |winner, player|\n (player.points <= winner.points && player.tricks_won.any?) ? player : winner\n end\n end",
"def take_worst\n roll_all.min\n end",
"def compute_best_distance sec\n min_improper,sec_improper=(min_proper,sec_proper=sec.divmod(60))\n if min_improper>0 and sec_improper<40\n min_improper-=1\n sec_improper+=60\n else\n #the improper time will be the same as the proper time, which\n #isn't a problem\n end\n proper=make_array(min_proper,sec_proper)\n improper=make_array(min_improper,sec_improper)\n [[\n compute_dist(proper,Primary),\n compute_dist(proper,Tiebreaker),\n proper\n ],[\n compute_dist(improper,Primary),\n compute_dist(improper,Tiebreaker),\n improper\n ]].sort[0][-1].join\nend",
"def personal_best\n personal_top_three.first\n end",
"def ubt_move(state)\n legal_moves = @game.legal_moves(state)\n best_move = nil\n best_bound = -999\n legal_moves.each do |move|\n upper_bound = ucb(state, move)\n if upper_bound > best_bound\n best_bound = upper_bound\n best_move = move\n end\n end\n # print \"\\r Examining #{best_move} Depth #{@depth} \"\n best_move\n end",
"def best_offense\n @teams.max_by { |team| team.average_goals_scored }.team_name\n end",
"def longest_improvement(grades)\n runs = []\n prev = 0\n run = 1\n grades.each do |g|\n if g >= prev then\n run +=1\n else\n runs << run\n run = 1\n end\n prev = g\n end\n\n puts runs.max\nend",
"def bestCand(voterOpinion, candList)\r\n\ttopCands = Array.new # []\r\n\ttopScore = nil\r\n\t\r\n\t# for each element in the candList array, calling the current element cand.\r\n\t#\tthe {/} are the same as the do/end shown in the Main section. \r\n\t#\tIncluded here to show the availabailty for different style choices\r\n\tcandList.each { |cand| \r\n\t\t\t\t\tcurrScore = getCandScore(voterOpinion,cand.drop(1))\r\n\t\t\t\t\tif topScore.nil? then\r\n\t\t\t\t\t\ttopScore = currScore\r\n\t\t\t\t\tend\r\n\t\t\t\t\tunless currScore < topScore # essentially if !(currScore < topScore)\r\n\t\t\t\t\t\t\r\n\t\t\t\t\t\tif currScore == topScore\r\n\t\t\t\t\t\t\ttopCands.push(cand[0])\r\n\t\t\t\t\t\telse # must be greater\r\n\t\t\t\t\t\t\ttopScore = currScore\r\n\t\t\t\t\t\t\ttopCands = [cand[0]]\r\n\t\t\t\t\t\tend\r\n\t\t\t\t\tend\r\n\t\t\t\t}\r\n\t\t\t\t\r\n\treturn topCands\r\nend",
"def board_elevator(elevator)\n elevator_direction = elevator.direction\n elevator_num = elevator.number\n if elevator.direction == \"up\"\n #board_people(elevator, @up_person_queue, @up_request_pending)\n board_people_up(elevator)\n @button_pairs[\"elevator#{elevator_num}\"][\"up\"] = false\n elsif elevator.direction == \"down\"\n #board_people(elevator, @down_person_queue, @down_request_pending)\n board_people_down(elevator)\n @button_pairs[\"elevator#{elevator_num}\"][\"down\"] = false\n end\n end",
"def best_distance_attempts\n best_attempts_for_each_competitor = competitors.map(&:max_successful_distance_attempt).compact\n\n best_attempts_for_each_competitor.sort{ |a, b| b.distance <=> a.distance }\n end",
"def par_compare(a, b)\n if a.par_price.price > b.par_price.price\n -1\n elsif a.par_price.price < b.par_price.price\n 1\n else\n @formed.find_index(a) < @formed.find_index(b) ? -1 : 1\n end\n end",
"def eval_res_distances\n self.greater_than_twenty_away = (self.position_one - self.position_two).abs > 20\n self.greater_than_50_away = (self.position_one - self.position_two).abs > 50\n self.greater_than_100_away = (self.position_one - self.position_two).abs > 100\n self.greater_than_200_away = (self.position_one - self.position_two).abs > 200\n self.greater_than_300_away = (self.position_one - self.position_two).abs > 300\n self.greater_than_400_away = (self.position_one - self.position_two).abs > 400\n self.greater_than_500_away = (self.position_one - self.position_two).abs > 500\n self.greater_than_600_away = (self.position_one - self.position_two).abs > 600\n self.greater_than_700_away = (self.position_one - self.position_two).abs > 700\n self.greater_than_800_away = (self.position_one - self.position_two).abs > 800\n self.greater_than_900_away = (self.position_one - self.position_two).abs > 900\n self.greater_than_1000_away = (self.position_one - self.position_two).abs > 1000\n self.greater_than_1100_away = (self.position_one - self.position_two).abs > 1100\n self.greater_than_1200_away = (self.position_one - self.position_two).abs > 1200\n self.greater_than_1300_away = (self.position_one - self.position_two).abs > 1300\n self.greater_than_1400_away = (self.position_one - self.position_two).abs > 1400\n self.greater_than_1500_away = (self.position_one - self.position_two).abs > 1500\n self.greater_than_1600_away = (self.position_one - self.position_two).abs > 1600\n self.greater_than_1700_away = (self.position_one - self.position_two).abs > 1700\n self.greater_than_1800_away = (self.position_one - self.position_two).abs > 1800\n self.greater_than_1900_away = (self.position_one - self.position_two).abs > 1900\n self.greater_than_2000_away = (self.position_one - self.position_two).abs > 2000\n self.greater_than_2100_away = (self.position_one - self.position_two).abs > 2100\n self.greater_than_2200_away = (self.position_one - self.position_two).abs > 2200\n self.greater_than_2300_away = (self.position_one - self.position_two).abs > 2300\n self.greater_than_2400_away = (self.position_one - self.position_two).abs > 2400\n self.greater_than_2500_away = (self.position_one - self.position_two).abs > 2500\n self.save\n end",
"def best_move\n\t\tpossible_moves.send(@turn == \"x\" ? :max_by: :min_by) { |idx| minimax(idx) }\n\tend",
"def runoff voters\n votes = get_leading_votes_from(voters)\n leading_candidate = who_has_most votes\n return leading_candidate if is_winner?(leading_candidate, votes)\n losers = who_has_least(votes, get_candidates_hash(voters))\n return nil if losers.empty?\n runoff(next_round(voters,losers))\nend",
"def min_refuel array_of_gas_station, total_distance, l_km\r\n\tt1 = Time.now\r\n\ttotal_refuel = 0\r\n\trefueld_at = []\r\n\tcan_travel = l_km\r\n\tflag = \"yes\"\r\n\tarray_of_gas_station.each_with_index do |arr,index|\r\n\t\tif arr > can_travel\r\n\t\t\tcan_travel += l_km\r\n\t\t\ttotal_refuel += 1\r\n\t\t\trefueld_at << (index-1)\r\n\t\telsif arr == can_travel\r\n\t\t\tcan_travel += l_km\r\n\t\t\ttotal_refuel += 1\r\n\t\t\trefueld_at << index\r\n\t\tend\r\n\tend\r\n\trefueld_at.each_with_index do |arr, i|\r\n\t\tif refueld_at[i] == refueld_at[i+1] || refueld_at[i] < 0\r\n\t\t\tflag = \"no\"\r\n\t\tend\r\n\tend\r\n\tif flag.eql? \"yes\"\r\n\t\tt2 = Time.now\r\n\t\tp \"total refuel : #{total_refuel}\"\r\n\t\tp \"refueled at : #{refueld_at}\"\r\n\t\tp \"Time taken : #{t2 - t1}\"\r\n\telse\r\n\t\tt2 = Time.now\r\n\t\tp \"can't travel\"\r\n\t\tp \"Time taken : #{t2 - t1}\"\r\n\tend\r\nend",
"def lowest_scoring_home_team\n @teams.min_by { |team| team.average_home_goals }.team_name\n end",
"def highest_earner(drivers)\n # hash data for the highest earning driver\n highest_earner_data = drivers.max { |a, b| a[:total_earned] <=> b[:total_earned]}\n # extracts the driver ID\n highest_earner = highest_earner_data[:driver_id]\n return highest_earner\nend",
"def winning_team\n if homeTeamPoints.sum > awayTeamPoints.sum\n \"Brooklyn Nets\"\n else\n \"Charlotte Hornets\"\n end\nend",
"def calculate_winner\n self.winner = case human.move <=> computer.move\n when 1\n human\n when -1\n computer\n when 0\n 'tie'\n end\n end",
"def winning_team\n home_points = collection_by_prop(game_hash[:home], :points).reduce(0, :+)\n away_points = collection_by_prop(game_hash[:away], :points).reduce(0, :+)\n home_points > away_points ? game_hash[:home][:team_name] : game_hash[:away][:team_name]\n end",
"def ap_to_next_job_level(job_hunt = @job_current)\n unless job_hunt == Unemployed\n for job in @job_history\n if job['name'] == job_hunt\n ap = job['ap']\n lvl = 0\n job_advert = get_job\n for i in 1...job_advert['max_lvl'] + 1\n key = 'lvl' + i.to_s\n if ap >= job_advert[key]\n ap -= job_advert[key]\n lvl += 1\n end\n end\n if job_advert['max_lvl'] == lvl\n ap = 0\n end\n return ap\n end\n end\n return 0\n end\n\n end",
"def delta_right_top\n\t\tif cl[0] > 1 \n\t\t\t[right_top, @map.grid[cl] - @map.grid[ right_top ]]\n\t\telse\n\t\t\t# give a very large number that will never be chosen\n\t\t\t[right_top, 99999999999]\n\t\tend\n\tend",
"def best_move\n find_at_risk_square(mark) ||\n find_at_risk_square(@human.mark) ||\n center_square ||\n corner_play ||\n board.unmarked_keys.sample\n end",
"def choose_top(i, j, tn, choices)\n choices << [0, nil] if !@align_globally\n @ts[tn][0][i][j] = choices.max {|a, b| a[0] <=> b[0]}[0]\n choices.each do |choice|\n if in_delta?(choice[0], @ts[tn][0][i][j])\n @ts[tn][1][i][j] << choice[1]\n end\n end\n end",
"def find_best_move\n return 5 if @board.unmarked_keys.count == 9\n\n bests = { val: -INFINITY, move: nil }\n\n board.squares.each do |cell, square|\n if square.unmarked?\n move_val = simulate_computer_move(cell)\n if move_val > bests[:val]\n bests[:val] = move_val\n bests[:move] = cell\n end\n end\n end\n bests[:move]\n end",
"def latest_is_personal_best?\n latest == personal_best\n end",
"def best_leaveit_card(leave_it)\r\n @log.debug(\"calculate best_leaveit_card\") \r\n w_cards = []\r\n leave_it.each do |card_lbl|\r\n card_s = card_lbl.to_s # something like '_Ab'\r\n segno = card_s[2,1] \r\n\r\n curr_w = 0\r\n curr_w += 200 if card_s[2] == @briscola.to_s[2]\r\n curr_w += 500 if card_s[1] == \"A\"[0]\r\n curr_w += 400 if card_s[1] == \"3\"[0] \r\n curr_w += 300 if card_s[1] == \"R\"[0] \r\n curr_w += 280 if card_s[1] == \"C\"[0] \r\n curr_w += @deck_info.get_card_info(card_lbl)[:rank]\r\n\r\n w_cards << [card_lbl, curr_w ]\r\n end\r\n min_list = w_cards.min{|a,b| a[1]<=>b[1]}\r\n @log.debug(\"Best card to play on leave it cards is #{min_list[0]}, w_cards = #{w_cards.to_s}\")\r\n return min_list[0]\r\n end",
"def most_likely_play\n @must_learn = true\n best_move = nil\n max = 0\n\n search_space = SearchSpace.new(@board, @most_alike_board, @color)\n search_space.each do |move|\n prob = probability_of(move)\n return move if prob >= Config::PROBS_THRESHOLD\n if max < prob\n max = prob\n best_move = move\n end\n end\n\n best_move\n end",
"def step()\n max = 0.0\n best = nil\n walk_tasks() do |t|\n if Task::STOPPED == t.state\n bu = t.backed_up()\n if max < bu\n best = t\n max = bu\n end\n end\n end\n best.step() unless best.nil?\n best\n end",
"def step()\n max = 0.0\n best = nil\n walk_tasks() do |t|\n if Task::STOPPED == t.state\n bu = t.backed_up()\n if max < bu\n best = t\n max = bu\n end\n end\n end\n best.step() unless best.nil?\n best\n end",
"def next_step\n\t\t# choose the next step based on the lowest absolute delta\n\t\tnext_step = [ delta_right_top, delta_right_mid, delta_right_bot ].min_by { |i| i[1].abs }\n\n\t\t# increase tot_elavation with the delta between current and next step\n\t\t@tot_elavation += next_step[1].abs\n\n\t\treturn next_step[0]\n\tend",
"def optimize\n left\n end",
"def optimize\n left\n end",
"def optimize\n left\n end",
"def vote\n elected = 0\n @output.each_index do |o|\n elected = @output[o] > @output[elected] ? o : elected\n end\n elected\n end"
] |
[
"0.7092161",
"0.6612731",
"0.65469885",
"0.6142631",
"0.5933778",
"0.5923163",
"0.59172934",
"0.5877978",
"0.58687085",
"0.5857423",
"0.58505124",
"0.58122474",
"0.57705396",
"0.5767235",
"0.57530624",
"0.5752622",
"0.5724877",
"0.5722437",
"0.57156116",
"0.57017064",
"0.56980056",
"0.56842107",
"0.56819195",
"0.56661886",
"0.5650543",
"0.5635807",
"0.56349534",
"0.5633906",
"0.5625",
"0.5622647",
"0.56223756",
"0.56126046",
"0.55998456",
"0.5594394",
"0.5589222",
"0.55818033",
"0.5580888",
"0.5574022",
"0.5568742",
"0.5562011",
"0.5551356",
"0.55508125",
"0.5532956",
"0.5518391",
"0.55145407",
"0.5501809",
"0.5496095",
"0.5494001",
"0.54900753",
"0.5489119",
"0.5488886",
"0.5482331",
"0.5468975",
"0.5468975",
"0.5455769",
"0.54403484",
"0.5428683",
"0.542271",
"0.54187083",
"0.54131526",
"0.5403444",
"0.5401186",
"0.5401186",
"0.53893125",
"0.53879464",
"0.5371258",
"0.53682524",
"0.536265",
"0.53608626",
"0.5349399",
"0.5344903",
"0.5341697",
"0.53342986",
"0.53327966",
"0.5332648",
"0.53307384",
"0.5328828",
"0.5323137",
"0.5317797",
"0.5309438",
"0.53014576",
"0.5300931",
"0.53000724",
"0.5299912",
"0.5297112",
"0.5295117",
"0.5292032",
"0.52883375",
"0.5281573",
"0.52752584",
"0.5274331",
"0.5270271",
"0.52641743",
"0.52595973",
"0.52595973",
"0.5252146",
"0.52482635",
"0.52482635",
"0.52482635",
"0.5248005"
] |
0.73192716
|
0
|
End getters Method to create floor request buttons
|
def makeFloorRequestButton
floorRequestButtonFloor = 1
for i in 1..@amountOfFloors
floorRequestButton = FloorRequestButton.new(i, 'off', floorRequestButtonFloor)
@floorRequestButtonsList.push(floorRequestButton)
floorRequestButtonFloor += 1
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create_floor_buttons\n for floor in 1..Elevator.num_floors do\n button = FloorButton.new(floor, self)\n @floor_buttons.append(button)\n end\n end",
"def create_call_buttons\n \n for floor in 1..Elevator.num_floors do\n \n up_btn = CallButton.new(floor, \"up\", self)\n @up_call_buttons.append(up_btn)\n\n down_btn = CallButton.new(floor, \"down\", self)\n @down_call_buttons.append(down_btn)\n end\n end",
"def createFloorButtonsList\n for x in 1..@numberOfFloors do\n @floorButtonsList.append(Button.new(x, ButtonStatus::ON, x))\n # puts \"elevator#{@id} button floor #{@floorButtonsList[x - 1].id} created\"\n end\n end",
"def push_button(floor)\n\t\t@buttons[floor] = true\n\tend",
"def buttons; end",
"def request_floor(elevator, requested_floor)\n floor_btn_to_press = elevator.floor_buttons.find { |btn| btn.floor == requested_floor } \n \n floor_btn_to_press.press()\n elevator.do_requests()\n end",
"def request_elevator(requested_floor, direction)\n if direction == \"up\"\n call_btn_to_press = @up_call_buttons.find { |btn| btn.floor == requested_floor } \n elsif direction == \"down\"\n call_btn_to_press = @down_call_buttons.find { |btn| btn.floor == requested_floor } \n end\n\n chosen_elevator = call_btn_to_press.press()\n chosen_elevator.do_requests()\n\n return chosen_elevator\n end",
"def render\n _button.btn.btn_primary request, onClick: self.click, disabled: @disabled\n end",
"def makeCallButtons\n callButtonId = 1\n callButtonFloor = 1\n for callButtonCounter in 1..@amountOfFloors\n #If not first floor\n if callButtonCounter > 1\n callButton = CallButton.new(callButtonId, 'off', callButtonFloor, 'down')\n @callButtonsList.push(callButton)\n callButtonId += 1\n end\n #If not last floor\n if callButtonCounter < @amountOfFloors\n callButton = CallButton.new(callButtonId, 'off', callButtonFloor, 'up')\n @callButtonsList.push(callButton)\n callButtonId += 1\n end\n callButtonFloor += 1\n end\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n params[:display] = @display if %w[all_vms vms resource_pools].include?(@display) # Were we displaying sub-items\n\n @refresh_div = 'main_div' unless @display # Default div for button.rjs to refresh\n case params[:pressed]\n when 'resource_pool_delete'\n deleteresourcepools\n if @refresh_div == 'main_div' && @lastaction == 'show_list'\n replace_gtl_main_div\n else\n render_flash unless performed?\n end\n when 'resource_pool_protect'\n assign_policies(ResourcePool)\n else\n super\n end\n end",
"def add_buttons\n @p_button = Chingu::Rect.new(510,5,20,20)\n Chingu::Text.create(:text=>\"p\",:x=>513,:y=>5,:factor_x =>1.5)\n @m_button = Chingu::Rect.new(540,5,20,20)\n Chingu::Text.create(:text=>\"m\",:x=>540,:y=>5,:factor_x =>1.5)\n @o_button = Chingu::Rect.new(570,5,20,20)\n Chingu::Text.create(:text=>\"o\",:x=>575,:y=>5,:factor_x =>1.5)\n @save_button = Chingu::Rect.new(5,5,45,20)\n Chingu::Text.create(:text=>\"save\",:x=>5,:y=>5,:factor_x =>1.5)\n @load_button = Chingu::Rect.new(60,5,45,20)\n Chingu::Text.create(:text=>\"load\",:x=>65,:y=>5,:factor_x =>1.5)\n end",
"def create_extra_buttons()\n Rectangle.new(x:5,y:50,width:40,height:40,color:\"white\",z:1)\n Rectangle.new(x:16,y:66,width:18,height:9,color:\"#ff7eec\",z:1)\n Rectangle.new(x:5,y:100,width:40,height:40,color:\"white\",z:1)\n Rectangle.new(x:14,y:110,width:21,height:25,color:'#808080',z:1)\n Rectangle.new(x:14,y:110,width:21,height:5,color:'blue',z:1)\n Rectangle.new(x:5,y:150,width:40,height:40,color:\"white\",z:1)\n Triangle.new(x1:15,x2:35,x3:25,y1:180,y2:180,y3:160,color:\"black\",z:1)\n Rectangle.new(x:5,y:200,width:40,height:40,color:\"white\",z:1)\n Triangle.new(x1:15,x2:35,x3:25,y1:210,y2:210,y3:230,color:\"black\",z:1)\nend",
"def btn_area_first\n\n\t\t@layer_btns = HBox.new( true, 0 )\n\t\t@layer_btns.set_size_request( 800 , 40 )\n\n\t\t@btn_sintrom = Button.new(\"Sintrom\")\n\t\t@btn_sintrom.set_size_request( 100, 40 )\n\t\t@btn_sintrom.signal_connect( \"clicked\" ) do\n\t\t\tmain_area_sintrom\n\t\tend\n\t\t@btn_agenda = Button.new(\"Agenda\")\n\t\t@btn_agenda.set_size_request( 100, 40 )\n\t\t@btn_agenda.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\t\t@btn_bdays = Button.new(\"Cumpleaños\")\n\t\t@btn_bdays.set_size_request( 100, 40 )\n\t\t@btn_bdays.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\t\t@btn_shifts = Button.new(\"Turnos\")\n\t\t@btn_shifts.set_size_request( 100, 40 )\n\t\t@btn_shifts.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\t\t@btn_exit = Button.new(\"Exit\")\n\t\t@btn_exit.set_size_request( 100, 40 )\n\t\t@btn_exit.signal_connect( \"clicked\" ) do\n\t\t\ton_exit\n\t\tend\n\n\t\t@layer_btns.add( @btn_sintrom )\n\t\t@layer_btns.add( @btn_agenda )\n\t\t@layer_btns.add( @btn_bdays )\n\t\t@layer_btns.add( @btn_shifts )\n\t\t@layer_btns.add( @btn_exit )\n\n\t\t@layer_general.put( @layer_btns, 0, 760 )\n\n\tend",
"def form_buttons(**opt)\n opt.reverse_merge!('data-manifest': object.id)\n buttons = super\n buttons << submission_button(**opt)\n buttons << export_button(**opt)\n buttons << import_button(**opt)\n buttons << comm_status(**opt)\n block_given? ? yield(buttons) : buttons\n end",
"def button\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n @refresh_div = \"main_div\" # Default div for button.rjs to refresh\n\n case params[:pressed]\n when 'miq_request_delete' then deleterequests\n when 'miq_request_edit' then request_edit\n when 'miq_request_copy' then request_copy\n when 'miq_request_reload' then handle_request_reload\n else javascript_flash(:text => _('Button not yet implemented'), :severity => :error)\n end\n end",
"def request_floor(floor)\n if floor == self.current_floor\n print self.id 'floor button pushed, we are already on this floor, opening doors'\n elsif floor > self.current_floor\n self.a_floor_was_requested(floor)\n self.up_queue.append(floor)\n self.up_queue.sort\n self.set_direction\n self.request_this_elevator\n elsif floor < self.current_floor\n self.a_floor_was_requested(floor)\n self.down_queue.append(floor)\n self.up_queue.sort.reverse\n self.set_direction\n self.request_this_elevator\n end\n end",
"def reset_button(floor)\n\t\t@buttons[floor] = false\n\tend",
"def how_to_create_buttons args\n # Define a button style\n args.state.button_style = { w: 82, h: 10, }\n\n # Render instructions\n args.state.button_message ||= \"Press a Button!\"\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: 42,\n y: 82,\n text: args.state.button_message,\n alignment_enum: 1)\n\n\n # Creates button one using a border and a label\n args.state.button_one_border = args.state.button_style.merge( x: 1, y: 32)\n args.nokia.borders << args.state.button_one_border\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: args.state.button_one_border.x + 2,\n y: args.state.button_one_border.y + NOKIA_FONT_SM_HEIGHT + 2,\n text: \"Button One\")\n\n # Creates button two using a border and a label\n args.state.button_two_border = args.state.button_style.merge( x: 1, y: 20)\n\n args.nokia.borders << args.state.button_two_border\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: args.state.button_two_border.x + 2,\n y: args.state.button_two_border.y + NOKIA_FONT_SM_HEIGHT + 2,\n text: \"Button Two\")\n\n # Initialize the state variable that tracks which button was clicked to \"\" (empty stringI\n args.state.last_button_clicked ||= \"--\"\n\n # If a click occurs, check to see if either button one, or button two was clicked\n # using the inside_rect? method of the mouse\n # set args.state.last_button_clicked accordingly\n if args.nokia.mouse_click\n if args.nokia.mouse_click.inside_rect? args.state.button_one_border\n args.state.last_button_clicked = \"One Clicked!\"\n elsif args.nokia.mouse_click.inside_rect? args.state.button_two_border\n args.state.last_button_clicked = \"Two Clicked!\"\n else\n args.state.last_button_clicked = \"--\"\n end\n end\n\n # Render the current value of args.state.last_button_clicked\n args.nokia.labels << args.nokia\n .default_label\n .merge(x: 42,\n y: 5,\n text: args.state.last_button_clicked,\n alignment_enum: 1)\nend",
"def shipping_add_edit_button\n # unit_test_no_generate: shipping_add_edit_button, button.className(create_ats_regex_string(\"ats-wis-shipaddrconfeditbtn\"))\n $tracer.trace(__method__)\n\t return ToolTag.new(button.className(create_ats_regex_string(\"ats-wis-shipaddrconfeditbtn\")), __method__)\n\tend",
"def linkwizard_startover_button\n $tracer.trace(__method__)\n return ToolTag.new(form.id(\"StartOver\").button.className(\"/btn/\") ,__method__)\n end",
"def render_buttons(doc, object)\n pid = doc['id']\n apo_pid = doc.apo_pid\n\n buttons = []\n if can?(:manage_content, object)\n buttons << {\n url: close_version_ui_item_path(pid),\n label: 'Close Version',\n check_url: workflow_service_closeable_path(pid)\n }\n\n buttons << {\n url: open_version_ui_item_path(pid),\n label: 'Open for modification',\n check_url: workflow_service_openable_path(pid)\n }\n end\n\n if can?(:manage_item, object)\n if object.is_a? Dor::AdminPolicyObject\n buttons << { url: edit_apo_path(pid), label: 'Edit APO', new_page: true }\n buttons << { url: new_apo_collection_path(apo_id: pid), label: 'Create Collection' }\n end\n\n buttons << {\n url: dor_reindex_path(pid: pid),\n label: 'Reindex',\n new_page: true\n }\n\n # note that the backend will also check can?(:manage_governing_apo, object, new_apo_id), but\n # we can't do that here, since we don't yet know what APO the user might move the object to.\n # so it's possible that the user will get this button even if there are no other APOs they're\n # allowed to move the object to.\n buttons << {\n url: set_governing_apo_ui_item_path(id: pid),\n label: 'Set governing APO',\n disabled: !object.allows_modification?\n }\n\n buttons << { url: new_item_workflow_path(item_id: pid), label: 'Add workflow' }\n\n buttons << {\n url: dor_path(pid: pid),\n label: 'Republish',\n check_url: workflow_service_published_path(pid),\n new_page: true\n }\n\n buttons << {\n url: purge_item_path(id: pid),\n label: 'Purge',\n new_page: true,\n confirm: 'This object will be permanently purged from DOR. This action cannot be undone. Are you sure?',\n disabled: !registered_only?(doc)\n }\n\n buttons << { url: source_id_ui_item_path(id: pid), label: 'Change source id' }\n buttons << { url: tags_ui_item_path(id: pid), label: 'Edit tags' }\n if [Dor::Item, Dor::Set].any? { |clazz| object.is_a? clazz } # these only apply for items, sets and collections\n buttons << { url: catkey_ui_item_path(id: pid), label: 'Manage catkey' }\n buttons << { url: collection_ui_item_path(id: pid), label: 'Edit collections' }\n end\n if object.datastreams.include? 'contentMetadata'\n buttons << { url: item_content_type_path(item_id: pid), label: 'Set content type' }\n end\n if object.datastreams.include? 'rightsMetadata'\n buttons << { url: rights_item_path(id: pid), label: 'Set rights' }\n end\n if object.datastreams.include?('identityMetadata') && object.identityMetadata.otherId('catkey').present? # indicates there's a symphony record\n buttons << { url: refresh_metadata_item_path(id: pid), label: 'Refresh descMetadata', new_page: true, disabled: !object.allows_modification? }\n end\n buttons << { url: manage_release_solr_document_path(pid), label: 'Manage release' }\n\n # TODO: add a date picker and button to change the embargo date for those who should be able to.\n buttons << { label: 'Update embargo', url: embargo_form_item_path(pid) } if object.is_a?(Dor::Item) && object.embargoed?\n\n end\n\n buttons\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n\n params[:display] = @display if [\"instances\"].include?(@display) # Were we displaying vms/hosts/storages\n params[:page] = @current_page if @current_page.nil? # Save current page for list refresh\n\n if params[:pressed] == \"custom_button\"\n custom_buttons\n return\n end\n\n if params[:pressed].starts_with?(\"instance_\") # Handle buttons from sub-items screen\n pfx = pfx_for_vm_button_pressed(params[:pressed])\n process_vm_buttons(pfx)\n\n # Control transferred to another screen, so return\n return if [\"#{pfx}_policy_sim\", \"#{pfx}_compare\", \"#{pfx}_tag\",\n \"#{pfx}_retire\", \"#{pfx}_protect\", \"#{pfx}_ownership\",\n \"#{pfx}_refresh\", \"#{pfx}_right_size\",\n \"#{pfx}_reconfigure\"].include?(params[:pressed]) &&\n @flash_array.nil?\n\n unless [\"#{pfx}_edit\", \"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n @refresh_div = \"main_div\"\n @refresh_partial = \"layouts/gtl\"\n show # Handle VMs buttons\n end\n elsif params[:pressed] == \"make_ot_orderable\"\n make_ot_orderable\n return\n elsif params[:pressed] == \"orchestration_template_copy\"\n orchestration_template_copy\n return\n elsif params[:pressed] == \"orchestration_templates_view\"\n orchestration_templates_view\n return\n else\n params[:page] = @current_page if @current_page.nil? # Save current page for list refresh\n @refresh_div = \"main_div\" # Default div for button.rjs to refresh\n case params[:pressed]\n when \"orchestration_stack_delete\"\n orchestration_stack_delete\n when \"orchestration_stack_retire\"\n orchestration_stack_retire\n when \"orchestration_stack_retire_now\"\n orchestration_stack_retire_now\n return\n when \"orchestration_stack_tag\"\n tag(OrchestrationStack)\n when params[:pressed] == \"custom_button\"\n custom_buttons\n return\n end\n return if %w[orchestration_stack_retire orchestration_stack_tag].include?(params[:pressed]) &&\n @flash_array.nil? # Tag screen showing, so return\n end\n\n check_if_button_is_implemented\n\n if single_delete_test\n single_delete_redirect\n elsif params[:pressed].ends_with?(\"_edit\") || [\"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n render_or_redirect_partial(pfx)\n elsif @refresh_div == \"main_div\" && @lastaction == \"show_list\"\n replace_gtl_main_div\n else\n render_flash unless performed?\n end\n end",
"def create_elevator_list\n \n for elevatorID in 1..Column.num_elevators do\n elevator = Elevator.new(elevatorID)\n elevator.create_floor_buttons()\n @elevator_list.append(elevator)\n end\n end",
"def add_the_button\n @theButton = UIButton.buttonWithType(UIButtonTypeRoundedRect)\n @theButton.setTitle('Refresh Weather!', forState:UIControlStateNormal)\n # @theButton.setTitleColor(BW.rgb_color(255, 255, 255), forState:UIControlStateNormal)\n @theButton.backgroundColor = BW.rgb_color(255, 255, 255)\n # @theButton.layer.borderColor = BW.rgb_color(255, 255, 255)\n # @theButton.layer.borderWidth = 0.5\n @theButton.layer.cornerRadius = 10\n @theButton.frame = [[center_h(200), (@view_height - 200)], [200,50]] #[[x-axis, y-axis], [width, height]]\n # @theButton.setTitle('Stop', forState:UIControlStateSelected)\n\n # Add an event for the button when touched\n # 'self' refers to the handler class for the action in which the callback is defined\n # buttonClicked is the method that will be called when the event happens\n # forControlEvents will take the event name\n @theButton.addTarget(self, action:'buttonClicked', forControlEvents:UIControlEventTouchUpInside)\n\n self.view.addSubview(@theButton)\n end",
"def requestElevator(requestedFloor, direction)\n if direction == ButtonDirection::UP\n @buttonsUpList[requestedFloor-1].status = ButtonStatus::ON\n else\n @buttonsDownList[requestedFloor-2].status = ButtonStatus::ON\n end\n\n puts \">> Someone request an elevator from floor <#{requestedFloor}> and direction <#{direction}> <<\"\n for x in @elevatorsList do\n puts \"Elevator#{x.id} | Floor: #{x.floor} | Status: #{x.status}\"\n end\n\n bestElevator = findElevator(requestedFloor, direction)\n bestElevator.addFloorToFloorList(requestedFloor) \n bestElevator.moveElevator(requestedFloor, self)\n end",
"def add_button_to_query(button); end",
"def all_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(@menu_tag.find.div.className(\"mm-content-base\").find.a.className(\"mainButton\"), format_method(__method__))\n end",
"def createButtonsDownList\n for x in 2..@numberOfFloors do\n @buttonsDownList.append(Button.new(x, ButtonStatus::OFF, x))\n # puts \"button down #{@buttonsDownList[x - 2].id} created\"\n end\n end",
"def generateButtons\n @moves = @battler.moves\n @nummoves = 0\n @oldindex = -1\n @x = []; @y = []\n for i in 0...4\n @button[\"#{i}\"].dispose if @button[\"#{i}\"]\n @nummoves += 1 if @moves[i] && @moves[i].id\n @x.push(@viewport.width/2 + (i%2==0 ? -1 : 1)*(@viewport.width/2 + 99))\n @y.push(@viewport.height - 90 + (i/2)*44)\n end\n for i in 0...4\n @y[i] += 22 if @nummoves < 3\n end\n @button = {}\n for i in 0...@nummoves\n # get numeric values of required variables\n movedata = GameData::Move.get(@moves[i].id)\n category = movedata.physical? ? 0 : (movedata.special? ? 1 : 2)\n type = GameData::Type.get(movedata.type).id_number\n # create sprite\n @button[\"#{i}\"] = Sprite.new(@viewport)\n @button[\"#{i}\"].param = category\n @button[\"#{i}\"].z = 102\n @button[\"#{i}\"].bitmap = Bitmap.new(198*2, 74)\n @button[\"#{i}\"].bitmap.blt(0, 0, @buttonBitmap, Rect.new(0, type*74, 198, 74))\n @button[\"#{i}\"].bitmap.blt(198, 0, @buttonBitmap, Rect.new(198, type*74, 198, 74))\n @button[\"#{i}\"].bitmap.blt(65, 46, @catBitmap, Rect.new(0, category*22, 38, 22))\n @button[\"#{i}\"].bitmap.blt(3, 46, @typeBitmap, Rect.new(0, type*22, 72, 22))\n baseColor = @buttonBitmap.get_pixel(5, 32 + (type*74)).darken(0.4)\n pbSetSmallFont(@button[\"#{i}\"].bitmap)\n pbDrawOutlineText(@button[\"#{i}\"].bitmap, 198, 10, 196, 42,\"#{movedata.real_name}\", Color.white, baseColor, 1)\n pp = \"#{@moves[i].pp}/#{movedata.total_pp}\"\n pbDrawOutlineText(@button[\"#{i}\"].bitmap, 0, 48, 191, 26, pp, Color.white, baseColor, 2)\n pbSetSystemFont(@button[\"#{i}\"].bitmap)\n text = [[movedata.real_name, 99, 4, 2, baseColor, Color.new(0, 0, 0, 24)]]\n pbDrawTextPositions(@button[\"#{i}\"].bitmap, text)\n @button[\"#{i}\"].src_rect.set(198, 0, 198, 74)\n @button[\"#{i}\"].ox = @button[\"#{i}\"].src_rect.width/2\n @button[\"#{i}\"].x = @x[i]\n @button[\"#{i}\"].y = @y[i]\n end\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n params[:display] = @display if %w(vms instances images).include?(@display)\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n return tag(\"CloudTenant\") if params[:pressed] == 'cloud_tenant_tag'\n if params[:pressed].starts_with?(\"vm_\", # Handle buttons from sub-items screen\n \"miq_template_\",\n \"guest_\",\n \"image_\",\n \"instance_\")\n\n pfx = pfx_for_vm_button_pressed(params[:pressed])\n process_vm_buttons(pfx)\n return if [\"#{pfx}_policy_sim\", \"#{pfx}_compare\", \"#{pfx}_tag\", \"#{pfx}_retire\",\n \"#{pfx}_protect\", \"#{pfx}_ownership\", \"#{pfx}_refresh\", \"#{pfx}_right_size\",\n \"#{pfx}_reconfigure\"].include?(params[:pressed]) &&\n @flash_array.nil?\n\n unless [\"#{pfx}_edit\", \"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n @refresh_div = \"main_div\"\n @refresh_partial = \"layouts/gtl\"\n show\n end\n elsif params[:pressed] == \"custom_button\"\n custom_buttons\n # custom button screen, so return, let custom_buttons method handle everything\n return\n end\n render_button_partial(pfx)\n end",
"def createButtonsUpList\n for x in 1..(@numberOfFloors - 1) do\n @buttonsUpList.append(Button.new(x, ButtonStatus::OFF, x))\n # puts \"button up #{@buttonsUpList[x - 1].id} created\"\n end\n end",
"def mgs_buy_as_guest_btn\n\t\t$tracer.trace(__method__)\n\t\treturn ToolTag.new(button.className(create_ats_regex_string(\"ats-buyasguest\")), __method__)\n\tend",
"def button_up(id); end",
"def request_button order\n g = Glysellin.gateways[order.payment_method.slug].new(order)\n g.render_request_button\n end",
"def create_line_item_button\n self.get_element(@browser, 'create')\n end",
"def createNewHypothesisButton()\n\t\treturn ButtonCreator.new(\n\t\t\t:assetName => 'plus.png', \n\t\t\t:assetSize => 40, \n\t\t\t:parent => self,\n\t\t\t:clicked => :btn_new_clicked\n\t\t)\n\tend",
"def create_buttons\n @buttons = Array.new(@image_indexes.size) do |i|\n UI::PSDKMenuButton.new(@viewport, @image_indexes[i], i)\n end\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n\n params[:display] = @display if [\"vms\", \"hosts\", \"storages\", \"instances\", \"images\", \"orchestration_stacks\"].include?(@display) # Were we displaying vms/hosts/storages\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n\n # Handle buttons from sub-items screen\n if params[:pressed].starts_with?(\"availability_zone_\",\n \"cloud_network_\",\n \"cloud_object_store_container_\",\n \"cloud_subnet_\",\n \"cloud_tenant_\",\n \"cloud_volume_\",\n \"ems_cluster_\",\n \"flavor_\",\n \"floating_ip_\",\n \"guest_\",\n \"host_\",\n \"image_\",\n \"instance_\",\n \"load_balancer_\",\n \"miq_template_\",\n \"network_port_\",\n \"network_router_\",\n \"orchestration_stack_\",\n \"security_group_\",\n \"storage_\",\n \"vm_\")\n\n case params[:pressed]\n # Clusters\n when \"ems_cluster_compare\" then comparemiq\n when \"ems_cluster_delete\" then deleteclusters\n when \"ems_cluster_protect\" then assign_policies(EmsCluster)\n when \"ems_cluster_scan\" then scanclusters\n when \"ems_cluster_tag\" then tag(EmsCluster)\n # Hosts\n when \"host_analyze_check_compliance\" then analyze_check_compliance_hosts\n when \"host_check_compliance\" then check_compliance_hosts\n when \"host_compare\" then comparemiq\n when \"host_delete\" then deletehosts\n when \"host_edit\" then edit_record\n when \"host_protect\" then assign_policies(Host)\n when \"host_refresh\" then refreshhosts\n when \"host_scan\" then scanhosts\n when \"host_tag\" then tag(Host)\n when \"host_manageable\" then sethoststomanageable\n when \"host_introspect\" then introspecthosts\n when \"host_provide\" then providehosts\n # Storages\n when \"storage_delete\" then deletestorages\n when \"storage_refresh\" then refreshstorage\n when \"storage_scan\" then scanstorage\n when \"storage_tag\" then tag(Storage)\n # Edit Tags for Network Manager Relationship pages\n when \"availability_zone_tag\" then tag(AvailabilityZone)\n when \"cloud_network_tag\" then tag(CloudNetwork)\n when \"cloud_object_store_container_tag\" then tag(CloudObjectStoreContainer)\n when \"cloud_subnet_tag\" then tag(CloudSubnet)\n when \"cloud_tenant_tag\" then tag(CloudTenant)\n when \"cloud_volume_tag\" then tag(CloudVolume)\n when \"flavor_tag\" then tag(Flavor)\n when \"floating_ip_tag\" then tag(FloatingIp)\n when \"load_balancer_tag\" then tag(LoadBalancer)\n when \"network_port_tag\" then tag(NetworkPort)\n when \"network_router_tag\" then tag(NetworkRouter)\n when \"orchestration_stack_tag\" then tag(OrchestrationStack)\n when \"security_group_tag\" then tag(SecurityGroup)\n end\n\n pfx = pfx_for_vm_button_pressed(params[:pressed])\n # Handle Host power buttons\n if [\"host_shutdown\", \"host_reboot\", \"host_standby\", \"host_enter_maint_mode\", \"host_exit_maint_mode\",\n \"host_start\", \"host_stop\", \"host_reset\"].include?(params[:pressed])\n powerbutton_hosts(params[:pressed].split(\"_\")[1..-1].join(\"_\")) # Handle specific power button\n else\n process_vm_buttons(pfx)\n # Control transferred to another screen, so return\n return if [\"host_tag\", \"#{pfx}_policy_sim\", \"host_scan\", \"host_refresh\", \"host_protect\",\n \"host_compare\", \"#{pfx}_compare\", \"#{pfx}_tag\", \"#{pfx}_retire\",\n \"#{pfx}_protect\", \"#{pfx}_ownership\", \"#{pfx}_refresh\", \"#{pfx}_right_size\",\n \"#{pfx}_reconfigure\", \"storage_tag\", \"ems_cluster_compare\",\n \"ems_cluster_protect\", \"ems_cluster_tag\", \"#{pfx}_resize\", \"#{pfx}_live_migrate\",\n \"#{pfx}_evacuate\"].include?(params[:pressed]) &&\n @flash_array.nil?\n\n unless [\"host_edit\", \"#{pfx}_edit\", \"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n @refresh_div = \"main_div\"\n @refresh_partial = \"layouts/gtl\"\n show # Handle EMS buttons\n end\n end\n else\n @refresh_div = \"main_div\" # Default div for button.rjs to refresh\n redirect_to :action => \"new\" if params[:pressed] == \"new\"\n deleteemss if params[:pressed] == \"#{@table_name}_delete\"\n arbitration_profile_edit if params[:pressed] == \"arbitration_profile_new\"\n arbitration_profile_edit if params[:pressed] == \"arbitration_profile_edit\"\n arbitration_profile_delete if params[:pressed] == \"arbitration_profile_delete\"\n refreshemss if params[:pressed] == \"#{@table_name}_refresh\"\n # scanemss if params[:pressed] == \"scan\"\n tag(model) if params[:pressed] == \"#{@table_name}_tag\"\n\n # Edit Tags for Middleware Manager Relationship pages\n tag(@display.camelize.singularize) if @display && @display != 'main' &&\n params[:pressed] == \"#{@display.singularize}_tag\"\n assign_policies(model) if params[:pressed] == \"#{@table_name}_protect\"\n check_compliance(model) if params[:pressed] == \"#{@table_name}_check_compliance\"\n edit_record if params[:pressed] == \"#{@table_name}_edit\"\n if params[:pressed] == \"#{@table_name}_timeline\"\n @showtype = \"timeline\"\n @record = find_by_id_filtered(model, params[:id])\n @timeline = @timeline_filter = true\n @lastaction = \"show_timeline\"\n tl_build_timeline # Create the timeline report\n drop_breadcrumb(:name => _(\"Timelines\"), :url => show_link(@record, :refresh => \"n\", :display => \"timeline\"))\n session[:tl_record_id] = @record.id\n javascript_redirect polymorphic_path(@record, :display => 'timeline')\n return\n end\n if params[:pressed] == \"#{@table_name}_perf\"\n @showtype = \"performance\"\n @record = find_by_id_filtered(model, params[:id])\n drop_breadcrumb(:name => _(\"%{name} Capacity & Utilization\") % {:name => @record.name},\n :url => show_link(@record, :refresh => \"n\", :display => \"performance\"))\n perf_gen_init_options # Intialize options, charts are generated async\n javascript_redirect polymorphic_path(@record, :display => \"performance\")\n return\n end\n if params[:pressed] == \"#{@table_name}_ad_hoc_metrics\"\n @showtype = \"ad_hoc_metrics\"\n @record = find_by_id_filtered(model, params[:id])\n drop_breadcrumb(:name => @record.name + _(\" (Ad hoc Metrics)\"), :url => show_link(@record))\n javascript_redirect polymorphic_path(@record, :display => \"ad_hoc_metrics\")\n return\n end\n if params[:pressed] == \"refresh_server_summary\"\n javascript_redirect :back\n return\n end\n if params[:pressed] == \"ems_cloud_recheck_auth_status\" ||\n params[:pressed] == \"ems_infra_recheck_auth_status\" ||\n params[:pressed] == \"ems_middleware_recheck_auth_status\" ||\n params[:pressed] == \"ems_container_recheck_auth_status\"\n if params[:id]\n table_key = :table\n _result, details = recheck_authentication\n add_flash(_(\"Re-checking Authentication status for this %{controller_name} was not successful: %{details}\") %\n {:controller_name => ui_lookup(:table => controller_name), :details => details}, :error) if details\n else\n table_key = :tables\n ems_ids = find_checked_items\n ems_ids.each do |ems_id|\n _result, details = recheck_authentication(ems_id)\n add_flash(_(\"Re-checking Authentication status for the selected %{controller_name} %{name} was not successful: %{details}\") %\n {:controller_name => ui_lookup(:table => controller_name),\n :name => @record.name,\n :details => details}, :error) if details\n end\n end\n add_flash(_(\"Authentication status will be saved and workers will be restarted for the selected %{controller_name}\") %\n {:controller_name => ui_lookup(table_key => controller_name)})\n render_flash\n return\n end\n\n custom_buttons if params[:pressed] == \"custom_button\"\n\n return if [\"custom_button\"].include?(params[:pressed]) # custom button screen, so return, let custom_buttons method handle everything\n return if [\"#{@table_name}_tag\", \"#{@table_name}_protect\", \"#{@table_name}_timeline\"].include?(params[:pressed]) &&\n @flash_array.nil? # Tag screen showing, so return\n check_if_button_is_implemented\n end\n\n if !@flash_array.nil? && params[:pressed] == \"#{@table_name}_delete\" && @single_delete\n javascript_redirect :action => 'show_list', :flash_msg => @flash_array[0][:message] # redirect to build the retire screen\n elsif params[:pressed] == \"host_aggregate_edit\"\n javascript_redirect :controller => \"host_aggregate\", :action => \"edit\", :id => find_checked_items[0]\n elsif params[:pressed] == \"cloud_tenant_edit\"\n javascript_redirect :controller => \"cloud_tenant\", :action => \"edit\", :id => find_checked_items[0]\n elsif params[:pressed] == \"cloud_volume_edit\"\n javascript_redirect :controller => \"cloud_volume\", :action => \"edit\", :id => find_checked_items[0]\n elsif params[:pressed].ends_with?(\"_edit\") || [\"arbitration_profile_new\", \"#{pfx}_miq_request_new\", \"#{pfx}_clone\",\n \"#{pfx}_migrate\", \"#{pfx}_publish\"].include?(params[:pressed])\n render_or_redirect_partial(pfx)\n else\n if @refresh_div == \"main_div\" && @lastaction == \"show_list\"\n replace_gtl_main_div\n else\n render_flash unless performed?\n end\n end\n end",
"def edit_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(@tag.find.input.id(\"/EditButton$/\"), format_method(__method__))\n end",
"def edit_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(@tag.find.input.id(\"/EditButton$/\"), format_method(__method__))\n end",
"def moreInfoButton\n @moreInfoButton ||= begin\n moreInfoButton = UIButton.buttonWithType(UIButtonTypeCustom)\n moreInfoButton.backgroundColor = UIColor.blackColor.colorWithAlphaComponent(0.7)\n moreInfoButton.font = UIFont.fontWithName(\"DIN-Light\", size:14)\n moreInfoButton.titleLabel.textColor = UIColor.whiteColor\n layer = moreInfoButton.layer\n layer.setBorderWidth 1\n layer.setBorderColor UIColor.lightGrayColor.CGColor\n layer.cornerRadius = 3\n moreInfoButton.frame = [[230, 400], [80, 30]]\n moreInfoButton.setTitle(\"More Info\", forState: UIControlStateNormal)\n moreInfoButton.addTarget(self, action: \"showMoreInfo\", forControlEvents: UIControlEventTouchUpInside)\n moreInfoButton\n end\n end",
"def button_up(id)\n\n end",
"def shipping_add_back_button\n # unit_test_no_generate: shipping_add_back_button, button.className(create_ats_regex_string(\"ats-wis-backtoshipaddedit\"))\n\t\t$tracer.trace(__method__)\n\t return ToolTag.new(button.className(create_ats_regex_string(\"ats-wis-backtoshipaddedit\")), __method__)\n\tend",
"def create_color_buttons()\n Rectangle.new(x:5,y:450,width:45,height:45,color:'red',z:1)\n Rectangle.new(x:55,y:450,width:45,height:45,color:'orange',z:1)\n Rectangle.new(x:105,y:450,width:45,height:45,color:'yellow',z:1)\n Rectangle.new(x:155,y:450,width:45,height:45,color:'green',z:1)\n Rectangle.new(x:205,y:450,width:45,height:45,color:'blue',z:1)\n Rectangle.new(x:255,y:450,width:45,height:45,color:'#EE82EE',z:1)\n Rectangle.new(x:305,y:450,width:45,height:45,color:'black',z:1)\n Rectangle.new(x:355,y:450,width:45,height:45,color:'#808080',z:1)\n Rectangle.new(x:405,y:450,width:45,height:45,color:'white',z:1)\nend",
"def get_button(buid, add_params = nil)\n params = {\n buid: buid\n }\n api_call('/global/buttons/:buid(.:format)',:get,params,add_params)\n end",
"def handling_method_buttons\n $tracer.trace(__method__)\n #unit_test_no_generate: handling_method_buttons, div.className(\"/hmethod/\"); GameStopCheckoutRadioButtons\n return GameStopCheckoutRadioButtons.new(ToolTag.new(div.className(\"/hmethod/\"), __method__, self), self)\n end",
"def render_button\n NfgUi::Components::Elements::Button.new({ **integrated_slat_action_button_component_options, body: (block_given? ? yield : body) }, view_context).render\n end",
"def nfs_pickup_at_store_button\n $tracer.trace(__method__)\n return ToolTag.new(img.className(create_ats_regex_string(\"ats-nfs-pickup-btn\")), __method__)\n end",
"def custom_button(entity, action, path, label)\n\t\temployee_icons = {\"show\" => 'icons/icons_01.gif',\n\t\t\t\t\t\t\"new\" => 'icons/icons_02.gif',\n\t\t\t\t\t \"del\" => 'icons/icons_03.gif',\n\t\t\t\t\t\t\"edit\" => 'icons/icons_04.gif'\n\t\t}\n\t\tassign_icons = { \"show\" => 'icons/icons_05.gif',\n\t\t\t\t\"new\" => 'icons/icons_06.gif',\n\t\t\t \"del\" => 'icons/icons_07.gif',\n\t\t\t\t\"edit\" => 'icons/icons_08.gif'\n\t\t}\n\t\tstore_icons = { \"show\" => 'icons/icons_09.gif',\n\t\t\t\t\"new\" => 'icons/icons_10.gif',\n\t\t\t \"del\" => 'icons/icons_11.gif',\n\t\t\t\t\"edit\" => 'icons/icons_12.gif'\n\t\t}\n\t\tjob_icons = { \"show\" => 'icons/icons_13.gif',\n\t\t\t\t\"new\" => 'icons/icons_14.gif',\n\t\t\t\t\"del\" => 'icons/icons_15.gif',\n\t\t\t \"edit\" => 'icons/icons_16.gif'\n\t\t}\t\n\t\tshift_icons = { \"show\" => 'icons/icons_17.gif',\n\t\t\t\t\"new\" => 'icons/icons_18.gif',\n\t\t\t\t\"del\" => 'icons/icons_19.gif',\n\t\t\t\t\"edit\" => 'icons/icons_20.gif'\n\t\t}\t\t\t\t\t\t\t \n\t\ticons = { \"employee\" => employee_icons, \n\t\t\t \"assignment\" => assign_icons, \n\t\t\t \"store\" => store_icons, \n\t\t\t \"job\" => job_icons, \n\t\t\t \"shift\" => shift_icons\n\t\t}\n\t\timg_tag = image_tag(icons[entity][action], :alt => label)\n\t\treturn '<a href=\"' + path + '\" class=\"btn btn-large ' + action + '\">' + label + \" \" + img_tag + '</a>'\n\tend",
"def order_lookup_button\n $tracer.trace(__method__)\n return ToolTag.new(input.id(create_ats_regex_string(\"/OrderLookup_SubmitButton/\")), __method__)\n end",
"def button_actions\n return @button_actions if @button_actions\n\n @button_actions = [proc {}]\n\n @button_actions << proc do\n @units = swap_units(@units || 'imperial')\n end\n\n @button_actions << proc do\n @disp = @disp == :temp ? :desc : :temp\n end\n\n @button_actions << proc do\n raise IndexError, 'Cancel button was pressed'\n end\n end",
"def brew_button_status; end",
"def form_button_for(obj, name = nil)\n name ||= obj.object.new_record? ? 'Create' : 'Update'\n\n obj.button name, class: 'btn btn-theme', data: { disable_with: raw(\"<i class='fa fa-circle-o-notch fa-spin'></i> Saving...\") }\n end",
"def button_up(id)\n end",
"def order_lookup2_button\n #unit_test_no_generate: order_lookup2_button, input.className(create_ats_regex_string(\"ats-ordrlkup2btn\"))\n $tracer.trace(__method__)\n return ToolTag.new(input.className(create_ats_regex_string(\"ats-ordrlkup2btn\")), __method__)\n end",
"def button_tech_demo\n x, y, w, h = 460, 160, 300, 50\n state.button ||= state.new_entity(:button_with_fade)\n\n # Adds w.half to x and h.half + 10 to y in order to display the text inside the button's borders.\n state.button.label ||= [x + w.half, y + h.half + 10, \"click me and watch me fade\", 0, 1]\n state.button.border ||= [x, y, w, h]\n\n if inputs.mouse.click && inputs.mouse.click.point.inside_rect?(state.button.border) # if mouse is clicked, and clicked inside button's border\n state.button.clicked_at = inputs.mouse.click.created_at # stores the time the click occurred\n end\n\n outputs.labels << state.button.label\n outputs.borders << state.button.border\n\n if state.button.clicked_at # if button was clicked (variable has a value and is not nil)\n\n # The appearance of the button changes for 0.25 seconds after the time the button is clicked at.\n # The color changes (rgb is set to 0, 180, 80) and the transparency gradually changes.\n # Change 0.25 to 1.25 and notice that the transparency takes longer to return to normal.\n outputs.solids << [x, y, w, h, 0, 180, 80, 255 * state.button.clicked_at.ease(0.25.seconds, :flip)]\n end\n end",
"def build\n @buttons = Hash.new\n create_palettes\n end",
"def handling_method_buttons\n $tracer.trace(__method__)\n # unit_test_no_generate: handling_method_buttons, input.className(create_ats_regex_string(\"ats-wis-shippingoptions\")).parent(\"div\").at(1); WebInStoreRadioButtons\n return WebInStoreRadioButtons.new(ToolTag.new(input.className(create_ats_regex_string(\"ats-wis-shippingoptions\")).parent(\"div\").at(1), __method__, self), self)\n end",
"def reservation_mini_button(text, object, options={})\n path = String.new\n\n case object.class.to_s\n when \"ComponentModel\"\n path = new_component_model_reservation_path(object, options)\n when \"ComponentModelDecorator\"\n path = new_component_model_reservation_path(object.model, options)\n when \"Kit\"\n path = new_kit_reservation_path(object, options)\n when \"KitDecorator\"\n path = new_kit_reservation_path(object.model, options)\n else\n raise \"Expected an instance of Kit, KitDecorator, ComponentModel or ComponentModelDecorator, got: #{ object.class }\"\n end\n link_to(text, path, :class => 'btn btn-mini')\n end",
"def requestFloor(floor)\n puts \"The elevator is requested to move to floor #{floor}.\"\n @floorRequestList.push(floor)\n sortFloorList()\n puts \"Elevator is moving.\"\n moveElevator()\n puts \"Elevator is #{@status}.\"\n doorController()\n if @floorRequestList.length() == 0\n @direction = nil\n @status = 'idle'\n end\n puts \"Elevator is #{@status}.\"\n end",
"def _button_4_command(*args)\n\n end",
"def buy_as_guest_button\n $tracer.trace(__method__)\n #unit_test_no_generate: buy_as_guest_button, li.id(\"guest_checkout_link\").find.button\n return ToolTag.new(li.id(\"guest_checkout_link\").find.button, __method__, self)\n end",
"def buy_as_guest_button\n $tracer.trace(__method__)\n #unit_test_no_generate: buy_as_guest_button, li.id(\"guest_checkout_link\").find.button\n return ToolTag.new(li.id(\"guest_checkout_link\").find.button, __method__, self)\n end",
"def seventeen_or_older_button\n $tracer.trace(__method__)\n #unit_test_no_generate: seventeen_or_older_button, button.id(\"over_17\")\n return ToolTag.new(button.id(\"over_17\"), __method__, self)\n\t\t#return ToolTag.new(button.className(\"ats-ofagebtn\"), __method__, self)\n end",
"def build_toolbar_button(url_hash)\n url_hash[:empty_selection] ||= url_hash[:single]\n url_hash[:build_callback] ||= :selection unless url_hash[:empty_selection]\n classes = ['grid_toolbar_item', 'button', 'ui-state-default', 'ui-corner-all']\n s = <<-EOS\njQuery('<div class=\"#{(classes + Array(url_hash[:class])).compact.join(' ')}\" />')\n .text('#{escape_javascript(url_hash[:name])}')\n .button()\n .click(\n #{hash_to_callback(url_hash)}\n ).appendTo('#t_' + #{format_type_to_js(@table_id)});\nEOS\n end",
"def load_btn option, event\n case option\n when \"info\"\n render partial: 'infoBtn', locals: { event_id: event.id }\n when \"join\"\n if event.isParticipant?(session[:user_id])\n render partial: 'quitBtn', locals: { event_id: event.id }\n else\n render partial: 'joinBtn', locals: { event_id: event.id }\n end\n when \"edit\"\n render partial: 'editBtn', locals: { event_id: event.id }\n when \"delete\"\n render partial: 'deleteBtn', locals: { event_id: event.id }\n end\n end",
"def my_button_to(text, path, objs)\n\n s = \"<form method=\\\"get\\\" action=\\\"#{path}\\\" class=\\\"button_to\\\">\n <div><input type=\\\"submit\\\" value=\\\"#{text}\\\"/></div>\"\n for obj in objs\n if(!obj.nil?)\n s+= \"<input type=\\\"hidden\\\" name=\\\"#{obj.class.to_s.downcase}_id\\\" value=\\\"#{obj.id}\\\" />\"\n end\n end\n\n s+= \"</form>\"\n\n return s.html_safe\n end",
"def button\n @refresh_div = \"main_div\" # Default div for button.rjs to refresh\n timeprofile_delete if params[:pressed] == \"tp_delete\"\n copy_record if params[:pressed] == \"tp_copy\"\n edit_record if params[:pressed] == \"tp_edit\"\n\n if !@refresh_partial && @flash_array.nil? # if no button handler ran, show not implemented msg\n add_flash(_(\"Button not yet implemented\"), :error)\n @refresh_partial = \"layouts/flash_msg\"\n @refresh_div = \"flash_msg_div\"\n end\n\n if params[:pressed].ends_with?(\"_edit\", \"_copy\")\n javascript_redirect(:action => @refresh_partial, :id => @redirect_id)\n else\n build_tabs\n render :update do |page|\n page << javascript_prologue\n page.replace(\"flash_msg_div\", :partial => \"layouts/flash_msg\")\n page << \"miqScrollTop();\" if @flash_array.present?\n page.replace_html(\"main_div\", :partial => \"ui_4\") # Replace the main div area contents\n page << javascript_reload_toolbars\n end\n end\n end",
"def create_action_buttons *labels\n @action_buttons = []\n _row = @height-3\n _col = (@width-(labels.count*8))/2\n _col = 5 if _col < 1\n\n labels.each_with_index do |l, ix|\n b = Button.new text: l, row: _row, col: _col\n _col += l.length+5\n @action_buttons << b\n @form.add_widget b\n b.command do\n @selected_index = ix\n throw(:close, ix)\n end\n end\n ## 2018-05-17 - associate RETURN ENTER key with first button (FIXME) should be Ok or Okay or user \n ## should have some say in this. Same for associating ESC with Cancel or Quit.\n @form.bind_key(10, \"Fire Ok button\") { @action_buttons.first.fire }\n end",
"def api_form_actions(object_name, options = {})\n \" <li><div class=\\\"form_actions\\\">\\n \" +\n submit_button(object_name, options[:submit_text]) + \"\\n \" + cancel_link +\n \"\\n </div></li>\"\n end",
"def createListTypeButtons\n @listTypeGroup = Qt::ButtonGroup.new\n allBtn = KDE::PushButton.new('All') do |w|\n w.objectName = 'switchButton'\n w.checkable = true\n w.autoExclusive = true\n connect(w, SIGNAL(:clicked), self, SLOT(:getList))\n end\n\n highlightsBtn = KDE::PushButton.new('Highlights') do |w|\n w.objectName = 'switchButton'\n w.setMinimumWidth(80)\n w.checkable = true\n w.autoExclusive = true\n connect(w, SIGNAL(:clicked), self, SLOT(:getList))\n end\n\n mostBtn = KDE::PushButton.new('Most Popular') do |w|\n w.objectName = 'switchButton'\n w.checkable = true\n w.autoExclusive = true\n connect(w, SIGNAL(:clicked), self, SLOT(:getList))\n end\n listTypeHLayout = Qt::HBoxLayout.new\n listTypeHLayout.addWidget(allBtn, 54) # 2nd parameter is stretch.\n listTypeHLayout.addWidget(highlightsBtn, 180)\n listTypeHLayout.addWidget(mostBtn,235)\n\n @listTypeGroup.addButton(allBtn, 0)\n @listTypeGroup.addButton(highlightsBtn, 1)\n @listTypeGroup.addButton(mostBtn, 2)\n @listTypeGroup.exclusive = true\n\n listTypeHLayout\n end",
"def button(criteria = T.unsafe(nil)); end",
"def buttons\n return [] if [@status, @is_reportable, @info_changeable].include?(nil)\n if @status == Statuses::PRIVATE\n return [Buttons::PREVIEW, Buttons::EDIT, Buttons::DESTROY]\n elsif @status == Statuses::PUBLIC\n return [Buttons::PREVIEW, Buttons::ADD]\n elsif @status == Statuses::LINKED\n return [Buttons::PREVIEW, Buttons::EDIT, Buttons::REMOVE]\n else\n return []\n end\n end",
"def add_actions; end",
"def handling_method_buttons\n $tracer.trace(format_method(__method__))\n return GameStopHandlingMethodRadioButtons.new(ToolTag.new(@tag.find.div.className(\"/hmethod/\"), format_method(__method__)))\n end",
"def buttons(&block)\n content = @template.capture(self, &block)\n @template.concat '<div class=\"buttons\">'\n @template.concat content\n @template.concat '</div>'\n end",
"def handling_method_buttons\n $tracer.trace(__method__)\n #unit_test_no_generate: handling_method_buttons, table.id(\"standard_handling_method_select\").find.tbody; GameStopMobileHandlingMethodRadioButtons\n return GameStopMobileHandlingMethodRadioButtons.new(ToolTag.new(table.id(\"standard_handling_method_select\").find.tbody, __method__, self), self)\n end",
"def mgs_hops_confirm_button\n $tracer.trace(__method__)\n return ToolTag.new(div.id(\"finish_button\"), __method__, self)\n\tend",
"def actions\n return NewServiceRequestEntity.new_request_what_dialog_actions(self)\n end",
"def submit_button_template(l = {})\n <<-END\n <div class=\"button\">#{l[:element]}</div>\n\t END\n end",
"def mgs_hops_continue_button\n $tracer.trace(__method__)\n return ToolTag.new(div.id(\"continue_button\"), __method__, self)\n\tend",
"def build_rebin_label_station_form(rebin_label_station,action,caption,is_edit = nil,is_create_retry = nil)\n\n#\t---------------------------------\n#\t Define fields to build form from\n#\t---------------------------------\n codes = Facility.find_all_by_facility_type_code(\"packhouse\").map{|g|[g.facility_code]}\n\tfield_configs = Array.new\n\tfield_configs[0] = {:field_type => 'TextField',\n\t\t\t\t\t\t:field_name => 'rebin_label_station_code'}\n\n\tif is_edit == false\n\t field_configs[1] = {:field_type => 'DropDownField',\n\t\t\t\t\t\t:field_name => 'packhouse_code',\n\t\t\t\t\t\t:settings => {:list => codes}}\n\telse\n\t field_configs[1] = {:field_type => 'LabelField',\n\t\t\t\t\t\t:field_name => 'packhouse_code'}\n\tend\n\n\n\tfield_configs[2] = {:field_type => 'TextField',\n\t\t\t\t\t\t:field_name => 'ip_address'}\n\n\tbuild_form(rebin_label_station,field_configs,action,'rebin_label_station',caption,is_edit)\n\nend",
"def actions2\n return NewServiceRequestEntity.new_request_what_dialog_actions(self)\n end",
"def shipping_add_addconfm_button\n # unit_test_no_generate: shipping_add_addconfm_button, button.className(create_ats_regex_string(\"ats-wis-shipaddrconfcontinuebtn\"))\n\t\t$tracer.trace(__method__)\n\t return ToolTag.new(button.className(create_ats_regex_string(\"ats-wis-shipaddrconfcontinuebtn\")), __method__)\n\tend",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n return tag(\"CloudVolumeSnapshot\") if params[:pressed] == 'cloud_volume_snapshot_tag'\n if params[:pressed] == 'cloud_volume_snapshot_delete'\n delete_cloud_volume_snapshots\n elsif @refresh_div == \"main_div\" && @lastaction == \"show_list\"\n replace_gtl_main_div\n else\n render_flash\n end\n end",
"def list\n @test_sub_group = TestSubGroup.all(:order => \"id DESC\")\n @button_name=params[:button_name]\n render :partial => \"list\"\n end",
"def generate_buttons(buttons:)\n fb_buttons = buttons.collect do |button|\n case button['type']\n when 'url'\n _button = {\n \"type\" => \"web_url\",\n \"url\" => button[\"url\"],\n \"title\" => button[\"text\"]\n }\n\n if button[\"webview_height\"].present?\n _button[\"webview_height_ratio\"] = button[\"webview_height\"]\n end\n\n if button['messenger_extensions'].present?\n _button['messenger_extensions'] = true\n end\n\n _button\n\n when 'payload'\n _button = {\n \"type\" => \"postback\",\n \"payload\" => button[\"payload\"],\n \"title\" => button[\"text\"]\n }\n\n when 'call'\n _button = {\n \"type\" => \"phone_number\",\n \"payload\" => button[\"phone_number\"],\n \"title\" => button[\"text\"]\n }\n\n when 'login'\n _button = {\n \"type\" => \"account_link\",\n \"url\" => button[\"url\"]\n }\n\n when 'logout'\n _button = {\n \"type\" => \"account_unlink\"\n }\n\n when 'nested'\n _button = {\n \"type\" => \"nested\",\n \"title\" => button[\"text\"],\n \"call_to_actions\" => generate_buttons(buttons: button[\"buttons\"])\n }\n\n else\n raise(Stealth::Errors::ServiceImpaired, \"Sorry, we don't yet support #{button[\"type\"]} buttons yet!\")\n end\n\n _button\n end\n\n fb_buttons\n end",
"def activate_button\n $tracer.trace(format_method(__method__))\n return ToolTag.new(input.id(\"/redirectImageButton$/\"), format_method(__method__))\n end",
"def build_query(buttons = T.unsafe(nil)); end",
"def draw\n @buttonLogin.draw\n @buttonClassicAI.draw\n @buttonOttoAI.draw\n @buttonHelp.draw\n\n @buttonHelpLogin.draw\n @buttonHelpClassicAI.draw\n @buttonHelpOttoAI.draw\n end",
"def join_now_button\n $tracer.trace(__method__)\n return ToolTag.new(a.id(\"/ctl00_content_ctl00_fragment_17442_ctl01_ctl00_ctl00_ctl05_CreateAccount/\"), __method__)\n end",
"def store_pickup_search_button\n $tracer.trace(__method__)\n #unit_test_no_generate: store_pickup_search_button, button.className(create_ats_regex_string(\"alternate_button\"))\n return ToolTag.new(button.className(create_ats_regex_string(\"alternate_button\")), __method__, self)\n end",
"def set_fab_button_options\n opt = { items: {}}\n case params[:action]\n when 'nothing'; opt = opt\n # when 'new'; #opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print?print_list=true', browser: 'new' }\n # when 'edit'; #opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print?print_list=true', browser: 'new' }\n # when 'show'; opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print', browser: 'new' }\n # when 'index'; opt[:items].merge! print: { ajax: 'get', icon: 'print', class: 'blue lighten-2', url: '/stock_items/print?print_list=true', browser: 'new' }\n end\n\n # = build_print_link(f.object, list: false, print_options: \"print_cmd=print_label\", button: 'icon-tag', text: 'Udskriv dæk label')\n @fab_button_options = opt\n end",
"def action_buttons\n button(class: 'btn icon-only btn-person btn-heart btn-group mr-2', type: \"button\") do\n i(class: 'ero-heart')\n end.on :click do\n AcceptWantToMeet.run(user_id: params.user.id).then do |response|\n GetRoomUserForContextAndJoin.run({ context_type: 'User', context_id: params.user.try(:id), user_id: params.user.try(:id) })\n .then do |room_user|\n ModalsService.open_modal('Messenger', { size_class: 'modal-lg messenger-modal', backdrop: 'static', initial_room_user_id: room_user.try(:id), is_paired: true })\n end.catch do |e|\n `toast.error('Nie udało się otworzyć czatu...')`\n end\n end.fail do |error|\n `toast.error(\"Ooops! Coś poszło nie tak.\")`\n end\n end\n button(class: 'btn icon-only btn-person btn-remove btn-group', type: \"button\") do\n i(class: 'ero-cross')\n end.on(:click) do |e|\n e.prevent_default\n e.stop_propagation\n remove_want_to_meet(params.user.id)\n end\n end",
"def edit_submit_button\n # unit_test_no_generate: edit_submit_button, button.className(create_ats_regex_string(\"ats-editsubmitbtn\"))\n $tracer.trace(__method__)\n return ToolTag.new(button.className(create_ats_regex_string(\"ats-editsubmitbtn\")), __method__)\n end",
"def buttons attrs = {}, &block\n Tagz.tag :div, { :class => 'form-buttons' }.merge(attrs), &block\n end",
"def create\n @quick_button = QuickButton.new(quick_button_params)\n @quick_button.user_id = current_user.id\n\n if !params.include?(:quick_button_event)\n @quick_button.errors.add(:quick_button_event, 'Please select a device')\n respond_to do |format|\n format.html {render :new}\n format.json {render json: { messages: @quick_button.errors.full_messages, result: :error }}\n end and return\n end\n\n if !params.require(:quick_button_event).include?(:actions)\n @quick_button.errors.add(:quick_button_event, 'At least one action must exists')\n respond_to do |format|\n format.html {render :new}\n format.json {render json: { messages: @quick_button.errors.full_messages, result: :error }}\n end and return\n end\n\n params[:quick_button_event][:actions].each do |key, action|\n @quick_button.actions.build(safe_quick_button_action_params(action))\n end\n\n respond_to do |format|\n if @quick_button.save\n format.html {redirect_to @quick_button, notice: 'Quick button was successfully created.'}\n format.json {render :show, status: :created, location: @quick_button}\n format.json {\n full_quick_button = render_to_string partial: 'quick_button/quick_button', locals: { quick_button: @quick_button }\n render json: { data: JSON::parse(full_quick_button), result: :ok }\n }\n else\n format.html {render :new}\n format.json {\n full_quick_button = render_to_string partial: 'quick_button/quick_button', locals: { quick_button: @quick_button }\n render json: { data: JSON::parse(full_quick_button), result: :ok }\n }\n end\n end\n\n # Send MQTT update to the corresponding device\n mqtt_send_quick_button_data()\n\n end",
"def button_down(id)\n if id == Gosu::KbEscape || id == Gosu::KbQ\n save\n close\n elsif id == Gosu::KbA\n @current_type = :terrain\n elsif id == Gosu::KbS\n @current_type = :enemies\n elsif id == Gosu::KbD\n @current_type = :candies\n elsif id == Gosu::KbLeft || id == Gosu::GpLeft\n @x_offset -= 1 if @x_offset > 0\n elsif id == Gosu::KbUp || id == Gosu::GpUp\n @y_offset -= 1 if @y_offset > 0\n elsif id == Gosu::KbRight || id == Gosu::GpRight\n @x_offset += 1 if @x_offset < LEVEL_WIDTH - 10\n elsif id == Gosu::KbDown || id == Gosu::GpDown\n @y_offset += 1 if @y_offset < LEVEL_HEIGHT - 10\n elsif id == Gosu::Kb1\n if @current_type == :terrain\n @current_selection = :background\n elsif @current_type == :enemies\n @current_selection = :slug\n elsif @current_type == :candies\n @current_selection = :soda\n end\n elsif id == Gosu::Kb2\n if @current_type == :terrain\n @current_selection = :platform\n elsif @current_type == :enemies\n @current_selection = :spikes\n elsif @current_type == :candies\n @current_selection = :gum\n end\n elsif id == Gosu::Kb3\n if @current_type == :terrain\n @current_selection = :player\n elsif @current_type == :enemies\n @current_selection = :mushroom\n elsif @current_type == :candies\n @current_selection = :chocolate\n end\n elsif id == Gosu::Kb4\n if @current_type == :terrain\n @current_selection = :door\n end\n elsif id == Gosu::Kb5\n if @current_type == :terrain\n @current_selection = :background2\n end\n elsif id == Gosu::MsLeft\n if @current_selection == :slug\n x = (mouse_x / SCALE).to_i\n x -= x % 32\n x += 32 * @x_offset\n y = (mouse_y / SCALE).to_i\n y -= y % 25\n y -= 12\n y += 25 * @y_offset\n @enemies.push(Slug.new(self, x, y))\n elsif @current_selection == :spikes\n x = (mouse_x / SCALE).to_i\n x -= x % 32\n x += 3\n y = (mouse_y / SCALE).to_i\n y -= y % 25\n y -= 12\n x += 32 * @x_offset\n y += 25 * @y_offset\n @enemies.push(Spikes.new(self, x, y))\n elsif @current_selection == :mushroom\n x = (mouse_x / SCALE).to_i\n x -= x % 32\n y = (mouse_y / SCALE).to_i\n y -= y % 25\n y += 6\n x += 32 * @x_offset\n y += 25 * @y_offset\n @enemies.push(Mushroom.new(self, x, y))\n elsif @current_selection == :player\n x = (mouse_x / SCALE).to_i\n x -= x % 32\n y = (mouse_y / SCALE).to_i\n y -= y % 25\n x += 32 * @x_offset\n y += 25 * @y_offset\n x += 2\n @player = [x, y]\n elsif @current_selection == :door\n x = (mouse_x / SCALE).to_i\n x -= x % 32\n y = (mouse_y / SCALE).to_i\n y -= y % 25\n x += 32 * @x_offset\n y += 25 * @y_offset\n y += 2 \n @door = [x, y]\n elsif @current_type == :candies\n x = (mouse_x / SCALE).to_i\n y = (mouse_y / SCALE).to_i\n x += 32 * @x_offset\n y += 25 * @y_offset\n @candies.push(Object.const_get(@current_selection.to_s.capitalize).new(self, x, y))\n end\n end\n end",
"def button\n @edit = session[:edit] # Restore @edit for adv search box\n params[:page] = @current_page unless @current_page.nil? # Save current page for list refresh\n return tag(\"CloudVolumeSnapshot\") if params[:pressed] == 'cloud_volume_snapshot_tag'\n if @refresh_div == \"main_div\" && @lastaction == \"show_list\"\n replace_gtl_main_div\n else\n render_flash\n end\n end",
"def create_base\n @base = UI::GenericBase.new(@viewport, BUTTON_TEXTS.collect { |txt| get_text(txt) }, BUTTON_KEYS)\n end"
] |
[
"0.725043",
"0.6995777",
"0.6883464",
"0.6748535",
"0.65568984",
"0.6451425",
"0.6248393",
"0.6185009",
"0.61505955",
"0.59828275",
"0.59518325",
"0.5936965",
"0.59348613",
"0.58649135",
"0.58584106",
"0.5817088",
"0.5807335",
"0.5726247",
"0.57021666",
"0.56969005",
"0.56808156",
"0.5671667",
"0.56325924",
"0.5623133",
"0.5622887",
"0.559443",
"0.55857295",
"0.55545706",
"0.5539023",
"0.5534045",
"0.55256987",
"0.5509927",
"0.55005753",
"0.5489529",
"0.54840994",
"0.5478064",
"0.5444673",
"0.54401857",
"0.5430889",
"0.5430889",
"0.53924716",
"0.5376649",
"0.53741705",
"0.53679705",
"0.53678",
"0.5359282",
"0.5345191",
"0.5336466",
"0.5330445",
"0.5321804",
"0.5320137",
"0.53102386",
"0.5306236",
"0.529161",
"0.52908236",
"0.52830625",
"0.5269799",
"0.5268252",
"0.52626175",
"0.5255507",
"0.52384233",
"0.52284276",
"0.52282894",
"0.5218364",
"0.5215184",
"0.52137715",
"0.5194841",
"0.51746875",
"0.5174608",
"0.5168359",
"0.51680934",
"0.51514864",
"0.51495224",
"0.5148934",
"0.5148718",
"0.5144347",
"0.5136284",
"0.5135333",
"0.5129419",
"0.51220906",
"0.51148146",
"0.5111255",
"0.5106375",
"0.5103178",
"0.5099164",
"0.5088539",
"0.50789976",
"0.5075587",
"0.50726694",
"0.50691974",
"0.5066569",
"0.5065754",
"0.5065636",
"0.5063598",
"0.50590664",
"0.5054057",
"0.5045418",
"0.5045126",
"0.50450146",
"0.50386953"
] |
0.77983236
|
0
|
User requesting floor inside elevator
|
def requestFloor(floor)
puts "The elevator is requested to move to floor #{floor}."
@floorRequestList.push(floor)
sortFloorList()
puts "Elevator is moving."
moveElevator()
puts "Elevator is #{@status}."
doorController()
if @floorRequestList.length() == 0
@direction = nil
@status = 'idle'
end
puts "Elevator is #{@status}."
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def request_floor(elevator, requested_floor)\n floor_btn_to_press = elevator.floor_buttons.find { |btn| btn.floor == requested_floor } \n \n floor_btn_to_press.press()\n elevator.do_requests()\n end",
"def requestElevator(floor, direction)\n puts \"A request for an elevator is made from floor #{floor}, going #{direction}.\"\n elevator = findBestElevator(floor, direction)\n puts \"Elevator #{elevator.elevatorId} is the best elevator, so it is sent.\"\n elevator.elevatorFloorRequestList.push(floor)\n elevator.sortFloorList()\n puts \"Elevator is moving.\"\n elevator.moveElevator()\n puts \"Elevator is #{elevator.elevatorStatus}.\"\n elevator.doorController()\n return elevator\n end",
"def requestFloor(requestedFloor, requestedColumn)\n puts \"\" \n puts \">> Someone inside the elevator#{@id} wants to go to floor <#{requestedFloor}> <<\"\n checkWeight($maxWeight)\n checkObstruction()\n addFloorToFloorList(requestedFloor)\n moveElevator(requestedFloor, requestedColumn)\n end",
"def requestElevator(requestedFloor, direction)\n if direction == ButtonDirection::UP\n @buttonsUpList[requestedFloor-1].status = ButtonStatus::ON\n else\n @buttonsDownList[requestedFloor-2].status = ButtonStatus::ON\n end\n\n puts \">> Someone request an elevator from floor <#{requestedFloor}> and direction <#{direction}> <<\"\n for x in @elevatorsList do\n puts \"Elevator#{x.id} | Floor: #{x.floor} | Status: #{x.status}\"\n end\n\n bestElevator = findElevator(requestedFloor, direction)\n bestElevator.addFloorToFloorList(requestedFloor) \n bestElevator.moveElevator(requestedFloor, self)\n end",
"def request_elevator(requested_floor, direction)\n if direction == \"up\"\n call_btn_to_press = @up_call_buttons.find { |btn| btn.floor == requested_floor } \n elsif direction == \"down\"\n call_btn_to_press = @down_call_buttons.find { |btn| btn.floor == requested_floor } \n end\n\n chosen_elevator = call_btn_to_press.press()\n chosen_elevator.do_requests()\n\n return chosen_elevator\n end",
"def elevators_at_floor(floor)\n\t\televators.select{|elevator| elevator.floor.eql? floor}\n\tend",
"def call_elevator elevator_number=0\n\t\t@elevators[elevator_number].add_to_floors_to_visit @floor_number\n\tend",
"def display_floor\n sleep($sleep_time)\n puts \"... Elevator #{@elevator.id}'s current floor mid-travel #{@elevator.current_floor} ...\"\n end",
"def request_floor(floor)\n if floor == self.current_floor\n print self.id 'floor button pushed, we are already on this floor, opening doors'\n elsif floor > self.current_floor\n self.a_floor_was_requested(floor)\n self.up_queue.append(floor)\n self.up_queue.sort\n self.set_direction\n self.request_this_elevator\n elsif floor < self.current_floor\n self.a_floor_was_requested(floor)\n self.down_queue.append(floor)\n self.up_queue.sort.reverse\n self.set_direction\n self.request_this_elevator\n end\n end",
"def receive_internal_request(elevator_id, requested_floor)\n (invalid_elevator_warning(elevator_id) and return) unless valid_elevator_id?(elevator_id)\n (invalid_floor_warning(requested_floor) and return) unless valid_floor?(requested_floor)\n\n elevator = @elevators.detect { |e| e.id == elevator_id }\n elevator.add_floor_to_destination_queue(requested_floor)\n elevator.perform_moves unless elevator.in_use?\n end",
"def find_closest_eligible_elevator(requested_direction, requested_floor)\n closest_eligible_elevator = elevators_sorted_by_call_proximity(requested_floor).detect do |e|\n e.eligible_for_pickup?(requested_direction, requested_floor)\n end\n if closest_eligible_elevator\n closest_eligible_elevator\n else\n find_closest_eligible_elevator(requested_direction, requested_floor)\n end\n end",
"def can_request_to?(floor)\n return false unless (building && elevator)\n constraints = self[:floor_constraints];\n general_keys = GENERAL_CONSTRAINTS.keys & constraints.keys\n keys = general_keys.select{ |k| GENERAL_CONSTRAINTS[k][self, floor] }\n keys.push(floor) if constraints[floor].present?\n return true if (keys.length == 0 && building.is_valid_floor?(floor))\n keys.any? do |k|\n needed_resolver = constraints[k];\n resolver = elevator.method(needed_resolver) && elevator.method(needed_resolver).call()\n resolver && resolver.accesToBuilding?(building) && resolver.have_access_to?(floor)\n end\n end",
"def request_this_elevator()\n self.set_direction\n self.status_update\n case self.direction\n when 0\n self.set_direction\n when 1\n if self.current_floor == self.up_queue[0]\n self.up_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor + 1\n\n if self.up_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n when -1\n if self.current_floor == self.down_queue[0]\n self.down_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor - 1\n if self.down_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n end\n end",
"def findElevator(currentFloor, direction)\n activeElevatorList = []\n idleElevatorList = []\n sameDirectionElevatorList = []\n for x in @elevatorsList\n if x.status != ElevatorStatus::IDLE #verify if elevator is active and if the request is on the elevator way\n if x.status == ElevatorStatus::UP and x.floor <= currentFloor or x.status == ElevatorStatus::DOWN and x.floor >= currentFloor\n activeElevatorList.append(x)\n end\n else\n idleElevatorList.append(x)\n end\n end\n\n if activeElevatorList.length > 0 #Create new list for elevators with same direction that the request\n sameDirectionElevatorList = activeElevatorList.select {|elevator| elevator.status == direction}\n end\n \n if sameDirectionElevatorList.length > 0\n bestElevator = findNearestElevator(currentFloor, sameDirectionElevatorList)\n else\n bestElevator = findNearestElevator(currentFloor, idleElevatorList)\n end\n \n return bestElevator\n end",
"def go_to_next_floor\n puts \"Elevator #{@id}, currently at floor #{@current_floor}, is about to go to floor #{@next_floor}...\"\n puts \"=====================================================================\"\n \n while @current_floor != @next_floor\n if @movement == \"up\"\n @current_floor += 1\n elsif (@movement == \"down\")\n @current_floor -= 1\n end\n @floor_display.display_floor()\n end\n\n puts \"======================================================================\"\n puts \"Elevator #{@id} has reached its requested floor! It is now at floor #{@current_floor}.\"\n end",
"def current_floor\n\t\t@current_floor\n\tend",
"def moveElevator(requestedFloor, requestedColumn)\n while @floorList.length() != 0\n if @status == ElevatorStatus::IDLE\n if @floor < requestedFloor\n @status = ElevatorStatus::UP\n elsif @floor == requestedFloor\n openDoors($waitingTime)\n deleteFloorFromList(requestedFloor)\n requestedColumn.buttonsUpList[requestedFloor-1].status = ButtonStatus::OFF\n requestedColumn.buttonsDownList[requestedFloor-1].status = ButtonStatus::OFF\n @floorButtonsList[requestedFloor-1].status = ButtonStatus::OFF\n else\n @status = ElevatorStatus::DOWN\n end\n end\n\n if @status == ElevatorStatus::UP\n moveUp(requestedColumn)\n else\n moveDown(requestedColumn)\n end\n\n end\n end",
"def elevator_print(floor)\r\n\t\televator_list.each do |elevator|\r\n\t\t\tif(floor.get_position == elevator.get_floor)\r\n\t\t\t\televator.to_s\r\n\t\t\tend\r\n\t\tend\r\n\t\tputs\r\n\tend",
"def set_floor\n @floor = Floor.find(params[:id])\n end",
"def set_floor\n @floor = Floor.find(params[:id])\n end",
"def findNearestElevator(currentFloor, selectedList)\n bestElevator = selectedList[0]\n bestDistance = (selectedList[0].floor - currentFloor).abs #abs() returns the absolute value of a number (always positive).\n \n for elevator in selectedList\n if (elevator.floor - currentFloor).abs < bestDistance\n bestElevator = elevator\n end\n end\n \n puts \"\"\n puts \" >> >>> ELEVATOR #{bestElevator.id} WAS CALLED <<< <<\"\n return bestElevator\n end",
"def set_floor\n @floor = Floor.find_by(id: params[:floor_id])\n end",
"def load_elevator\n while(@elevator.has_room? && @floors[0].is_empty?)\n @elevator.enter(@floors[0].dequeue)\n end\n end",
"def show\n if (current_user.role == \"customer\" || current_user.role == \"supervisor\")\n if params[:location_id].present?\n add_breadcrumb 'Location', 'locations_path'\n add_breadcrumb \"#{Location.where(:id => params[:location_id])[0].nickname}\", '#' \n add_breadcrumb \"Floors\", 'floors_path(:location_id => \"#{params[:location_id]}\")'\n add_breadcrumb \"View\", '#' \n end \n @floor = Floor.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @floor }\n end\n else\n redirect_to error_users_path and return\n end \n end",
"def choose_elevator\n elevator_scores = []\n\n for elevator in @column.elevator_list do\n \n # Initialize score to 0\n score = 0\n floor_difference = elevator.current_floor - @floor\n\n # Prevents use of any offline/under-maintenance elevators\n if elevator.status != \"online\"\n score = -1\n elevator_scores.append(score)\n else\n\n # Bonify score based on difference in floors\n if floor_difference == 0\n score += 5000\n else\n score += 5000/(floor_difference.abs() + 1)\n end\n \n # Bonify score based on direction (highest priority)\n if elevator.movement != \"idle\"\n if floor_difference >= 0 and @direction == \"down\" and elevator.movement == \"down\"\n \n # Paths are crossed going down, therefore favor this elevator\n score += 10000\n \n elsif floor_difference <= 0 and @direction == \"up\" and elevator.movement == \"up\"\n\n # Paths are crossed going down, therefore favor this elevator\n score += 10000\n \n else\n \n # Paths are not crossed, therefore try avoiding the use of this elevator\n score = 0\n \n # Give redemption points, in worst case scenario where all elevators never cross paths\n next_floor_difference = elevator.next_floor - @floor\n if next_floor_difference == 0\n score += 500\n else\n score += 500/(next_floor_difference.abs() + 1)\n end\n end\n end\n\n # Bonify score on request queue size (the smaller number of pre-existing requests, the faster therefore the better)\n if elevator.requests_queue.length() <= 3\n score += 1000\n elsif elevator.requests_queue.length() <= 7\n score += 250\n end\n \n # Send total score of elevator to the scores list\n elevator_scores.append(score)\n end\n end\n\n # Get value of highest score\n highest_score = -1\n for score in elevator_scores do\n if (score > highest_score)\n highest_score = score\n end\n end\n \n # Get elevator with the highest score (or nil if all elevators were offline\n chosen_elevator = nil\n if (highest_score > -1)\n chosen_elevator = @column.elevator_list[elevator_scores.find_index(highest_score)]\n puts \"Chosen elevator: Elevator #{chosen_elevator.id}\"\n end\n return chosen_elevator\n end",
"def go_to_origin\n @next_floor = @origin_floor\n puts \"Elevator #{@id} going back to origin...\"\n go_to_next_floor()\n end",
"def addFloorToFloorList(floor)\n @floorList.append(floor)\n puts \"Elevator#{@id} - floor #{floor} added to floorList\"\n end",
"def hit_floor\n return nil if rising?\n what_object_hit_me_on_the :side => :bottom, :restrict => Standable, :look_ahead => 10, :margin_of_error => 25\n end",
"def send_request(elevator)\n request = Request.new(@floor, @direction)\n elevator.requests_queue.append(request)\n end",
"def set_floor\n @floor = Floor.with_deleted.find(params[:id])\n end",
"def elevator\n elevators.sort_by { |e| e.stop_count }.first\n end",
"def itemsOnFloor(input, floor)\n input.select { |key, value| value == floor}.keys - [:elevator]\nend",
"def state\n\t\t@flrs.each do |f|\n\t\t\tputs \"Floor #{@flrs.index(f)} has #{f.passengers.length} passengers waiting.\"\n\t\tend\n\t\t@elevators.each do |e|\n\t\t\tputs \"Elevator #{@elevators.index(e)} is in floor #{@flrs.index(e.current_floor)}, #{e.direction} with #{e.passengers.length} passengers\"\n\t\tend\n\tend",
"def receive_call(requested_direction, requested_floor)\n (invalid_direction_warning(requested_direction) and return) unless valid_direction?(requested_direction)\n (invalid_floor_warning(requested_floor) and return) unless valid_floor?(requested_floor)\n\n elevator = find_closest_eligible_elevator(requested_direction, requested_floor)\n elevator.add_floor_to_destination_queue(requested_floor)\n elevator.perform_moves unless elevator.in_use?\n end",
"def board_elevator(elevator)\n elevator_direction = elevator.direction\n elevator_num = elevator.number\n if elevator.direction == \"up\"\n #board_people(elevator, @up_person_queue, @up_request_pending)\n board_people_up(elevator)\n @button_pairs[\"elevator#{elevator_num}\"][\"up\"] = false\n elsif elevator.direction == \"down\"\n #board_people(elevator, @down_person_queue, @down_request_pending)\n board_people_down(elevator)\n @button_pairs[\"elevator#{elevator_num}\"][\"down\"] = false\n end\n end",
"def get_floor()\n get_parent(\"FLOOR\")\n end",
"def new\n if (current_user.role == \"customer\" || current_user.role == \"supervisor\")\n if params[:location_id].present?\n add_breadcrumb 'Location', 'locations_path'\n add_breadcrumb \"#{Location.where(:id => params[:location_id])[0].nickname}\", '#' \n add_breadcrumb \"Floors\", 'floors_path(:location_id => \"#{params[:location_id]}\")'\n add_breadcrumb \"Add new\", '#'\n end \n @floor = Floor.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @floor }\n end\n else\n redirect_to error_users_path and return\n end\n end",
"def floor_params\n params.require(:floor).permit(:building_id, :floor)\n end",
"def get_floor()\n get_parent(\"FLOOR\")\n end",
"def scenario1()\n puts \"\"\n puts \"****************************** SCENARIO 1: ******************************\"\n columnScenario1 = Column.new(1, ColumnStatus::ACTIVE, 10, 2) #parameters (id, ColumnStatus.ACTIVE/INACTIVE, numberOfFloors, numberOfElevators)\n columnScenario1.display() \n columnScenario1.elevatorsList[0].floor = 2 #floor where the elevator 1 is\n columnScenario1.elevatorsList[1].floor = 6 #floor where the elevator 2 is\n \n puts \"\"\n puts \"Person 1: (elevator 1 is expected)\"\n columnScenario1.requestElevator(3, ButtonDirection::UP) #parameters (requestedFloor, buttonDirection.UP/DOWN)\n columnScenario1.elevatorsList[0].requestFloor(7, columnScenario1) #parameters (requestedFloor, requestedColumn)\n puts \"==================================\"\nend",
"def elevator\n if params[:column].present?\n @elevator = Elevator.where(column_id:params[:column])\n else\n @elevator = Elevator.all\n end\n\n respond_to do |format|\n format.json {\n render json: {elevator: @elevator}\n \n }\n end\n end",
"def floor(floor_number)\n\t\t@flrs[floor_number]\n\tend",
"def top_floor\n\t\t@flrs.last\n\tend",
"def step\n\t\t@elevators.each do |elevator|\n\t\t\tif elevator.current_floor == @floor_number\n\t\t\t\twhile !@persons_queue.empty?\n\t\t\t\t\tif elevator.number_of_occupants < elevator.max_capacity\n\t\t\t\t\t\televator.add_occupant @persons_queue.shift\n\t\t\t\t\telse\n\t\t\t\t\t\tbreak\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def send_request\n request = Request.new(@floor, @direction)\n @elevator.requests_queue.append(request)\n end",
"def final_floor\n floors.last\n end",
"def set_floor_plan\n @floor_plan = FloorPlan.find(params[:id])\n end",
"def set_floor_plan\n @floor_plan = FloorPlan.find(params[:id])\n end",
"def create\n if params[:floor][:loc_id].empty?\n params[:floor].delete :loc_id \n else\n params[:floor][:location_id] = params[:floor][:loc_id]\n params[:floor].delete :loc_id\n end\n @floor = Floor.new(params[:floor])\n @floor.user_id = current_user.id\n if current_user.role == \"customer\"\n floor_count = Floor.where(:delflag => \"false\", :user_id => \"#{current_user.id}\").count\n @children = current_user.children\n @children.each do |child|\n floor_count = floor_count + Floor.where(:delflag => \"false\", :user_id => child.id).count\n end\n restriction = UserConfig.where(:user_id => \"#{current_user.id}\")\n else\n floor_count = Floor.where(:delflag => \"false\", :user_id => \"#{current_user.parent.id}\").count\n @children = current_user.parent.children\n @children.each do |child|\n floor_count = floor_count + Floor.where(:delflag => \"false\", :user_id => child.id).count\n end\n restriction = UserConfig.where(:user_id => \"#{current_user.parent.id}\")\n end \n if restriction.blank?\n respond_to do |format|\n if @floor.save\n params[:floor][:location_id] = @floor.location_id\n format.html { redirect_to floors_path(:location_id => params[:floor][:location_id]), notice: 'Floor was successfully created.' }\n format.json { render json: @floor, status: :created, location: @floor }\n else\n format.html { render action: \"new\" }\n format.json { render json: @floor.errors, status: :unprocessable_entity }\n end\n end\n elsif restriction.present? && floor_count < restriction[0].floorcapacity\n respond_to do |format|\n if @floor.save\n params[:floor][:location_id] = @floor.location_id\n format.html { redirect_to floors_path(:location_id => params[:floor][:location_id]), notice: 'Floor was successfully created.' }\n format.json { render json: @floor, status: :created, location: @floor }\n else\n format.html { render action: \"new\" }\n format.json { render json: @floor.errors, status: :unprocessable_entity }\n end\n end\n else\n flash[:notice] = \"You are not allowed to create more floors because you have already reach your limit\"\n render action: \"new\" and return\n end \n end",
"def floor\n end",
"def set_and_authorize_floor_plan\n @floor_plan = FloorPlan.find_by_id(params[:id])\n authorize @floor_plan\n true\n end",
"def next_elevator\n strategies.map { |strategy| strategy.elevator(elevators, request) }.first\n end",
"def floor_params\n params.require(:floor).permit(:name, :description, :building_id, :editor_data)\n end",
"def clock_tick\n\t\t@elevator_strategy.has_incoming_elevators?(self)\n\t\tif not @passengers.empty? && @make_new_request == false\n\t\t\t@elevator_strategy.request_elevator(self)\n\t\t\t@make_new_request = false\n\t\tend\n\tend",
"def show\n nodes = Node.get_coordinates(params[:id])\n @floor_plan = { 'floor_plan': nodes }\n respond_to do |format|\n if !nodes.blank?\n format.json { render json: @floor_plan, status: :ok }\n else\n format.json { render json: @floor_plan, status: :not_found }\n end\n end\n end",
"def people_on_current_floor()\n floors = @building.floors\n curr_floor = floors[@current_floor]\n wanting_up = curr_floor.up_person_queue\n wanting_down = curr_floor.down_person_queue\n if wanting_up.size() == 0 && wanting_down.size() == 0\n return \"stationary\"\n elsif wanting_up.size() > wanting_down.size()\n return \"up\"\n else # there are more or as many ppl wanting to go down\n return \"down\"\n end\n end",
"def change_status(start_floor, end_floor)\n\t\t#Determines whether the elevator's status changes\n\t\tif end_floor > start_floor\n\t\t\tset_status(\"up\")\n\t\telsif end_floor < start_floor\n\t\t\tset_status(\"down\")\n\t\telse end_floor < start_floor\n\t\t\tset_status(\"stationary\")\n\t\tend\n\tend",
"def do_requests\n if @requests_queue.length() > 0\n # Make sure queue is sorted before any request is completed\n sort_requests_queue()\n request = @requests_queue[0]\n\n # Go to requested floor\n @next_floor = request.floor\n go_to_next_floor()\n\n # Remove request after it is complete\n @door.open_door()\n @requests_queue.delete(request)\n\n # Automatically close the door\n @door.close_door()\n end\n\n # Automatically go idle if 0 requests or at the end of request\n @movement = \"idle\"\n end",
"def get_elevator\n if params[:column].present?\n @elevators = Column.find(params[:column]).elevators\n else\n @elevators = Column.all\n end\n if request.xhr?\n respond_to do |format|\n format.json {\n render json: {elevators: @elevators}\n }\n end\n end\n end",
"def show\n @floor = Floor.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @floor }\n end\n end",
"def floor_number\n return @floor_number\n end",
"def checkroom(r)\n case r.status\n when :plan\n # moot\n when :dig\n # designation cancelled: damp stone etc\n r.dig\n when :dug, :finished\n # cavein / tree\n r.dig\n # tantrumed furniture\n r.layout.each { |f|\n next if f[:ignore]\n t = df.map_tile_at(r.x1+f[:x].to_i, r.y1+f[:y].to_i, r.z1+f[:z].to_i)\n if (f[:bld_id] and not df.building_find(f[:bld_id]))\n df.add_announcement(\"AI: fix furniture #{f[:item]} in #{r.type} #{r.subtype}\", 7, false) { |ann| ann.pos = t }\n f.delete :bld_id\n @tasks << [:furnish, r, f]\n end\n if f[:construction]\n try_furnish_construction(r, f, t)\n end\n }\n # tantrumed building\n if r.misc[:bld_id] and not r.dfbuilding\n df.add_announcement(\"AI: rebuild #{r.type} #{r.subtype}\", 7, false) { |ann| ann.pos = r }\n r.misc.delete :bld_id\n construct_room(r)\n end\n end\n end",
"def bottom_floor\n\t\t@flrs.first\n\tend",
"def marked_floor?(floor = nil)\n floor ||= @current_floor\n marked_floors.include? floor\n end",
"def index\n @floor_plans = FloorPlan.all\n authorize @floor_plans\n end",
"def updateDisplays(elevatorFloor)\n for display in @floorDisplaysList\n display.floor = elevatorFloor\n end\n \n puts \"Displays show ##{elevatorFloor}\"\n end",
"def index\n @floor_plans = @location.floor_plans\n end",
"def set_floor_plan\n @floor_plan = @product.floor_plans.find(params[:id])\n end",
"def travel_to!(floor)\n passengers.each {|passenger| passenger.current_floor = self.current_floor}\n\nend",
"def link_to_floor_plan(location)\n link_to 'Show Floor Plan', display_floor_plan_path(location) if has_floor_plan?(location)\n end",
"def floor\n self\n end",
"def floor\n self\n end",
"def create_elevators\n @elevator_number.times do |i|\n floor_gap = @building.floors / @elevator_number * i\n elevator_list.append(Elevator.new(i, 1 + floor_gap, 1 + floor_gap))\n end\n end",
"def show\n @companies = Company.where('floor_id = ?', @floor.id)\n @spaces = MeetingRoom.where('floor_id = ?', @floor.id)\n end",
"def set_direction()\n case self.direction\n when 0\n if self.up_queue.length > self.down_queue.length\n self.direction = 1\n elsif self.up_queue.length < self.down_queue.length\n self.direction = -1\n else\n self.direction = 0\n end\n when 1\n if self.up_queue.length > 0\n self.direction = 1\n elsif self.up_queue.length == 0\n if self.down_queue.length > 0\n self.direction = -1\n else\n self.direction = 0\n end\n end\n when -1\n if self.down_queue.length > 0\n self.direction = -1\n elsif self.down_queue.length == 0\n if self.up_queue.length > 0\n self.direction = 1\n else\n self.direction = 0\n end\n end\n end\n\n # handles requests while its queue is not empty\n\n def request_this_elevator()\n self.set_direction\n self.status_update\n case self.direction\n when 0\n self.set_direction\n when 1\n if self.current_floor == self.up_queue[0]\n self.up_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor + 1\n\n if self.up_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n when -1\n if self.current_floor == self.down_queue[0]\n self.down_queue.shift\n self.status_update\n if self.down_queue.length + self.up_queue.length == 0\n self.direction = 0\n self.status_update\n self.here\n end\n else\n self.current_floor = self.current_floor - 1\n if self.down_queue.length > 0\n return self.request_this_elevator\n else\n self.direction = 0\n end\n end\n end\n end\n\n # responds to floor requests from within the elevator\n\n def request_floor(floor)\n if floor == self.current_floor\n print self.id 'floor button pushed, we are already on this floor, opening doors'\n elsif floor > self.current_floor\n self.a_floor_was_requested(floor)\n self.up_queue.append(floor)\n self.up_queue.sort\n self.set_direction\n self.request_this_elevator\n elsif floor < self.current_floor\n self.a_floor_was_requested(floor)\n self.down_queue.append(floor)\n self.up_queue.sort.reverse\n self.set_direction\n self.request_this_elevator\n end\n end\n end",
"def set_restaurant_floor_plan\n @restaurant_floor_plan = RestaurantFloorPlan.find(params[:id])\n end",
"def show\n @request = Request.find(params[:id])\n\n if current_user.admin?\n @available_rooms = get_available_rooms @request\n end\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @request }\n end\n end",
"def checkroom(r)\n case r.status\n when :plan\n # moot\n when :dig\n # designation cancelled: damp stone etc\n r.dig\n when :dug, :finished\n # cavein / tree\n r.dig\n # tantrumed furniture\n r.layout.each { |f|\n next if f[:ignore]\n if f[:bld_id] and not df.building_find(f[:bld_id])\n df.add_announcement(\"AI: fix furniture #{f[:item]} in #{r.type} #{r.subtype}\", 7, false) { |ann| ann.pos = [r.x1+f[:x].to_i, r.y1+f[:y].to_i, r.z1+f[:z].to_i] }\n f.delete :bld_id\n @tasks << [:furnish, r, f]\n end\n }\n # tantrumed building\n if r.misc[:bld_id] and not r.dfbuilding\n df.add_announcement(\"AI: rebuild #{r.type} #{r.subtype}\", 7, false) { |ann| ann.pos = r }\n r.misc.delete :bld_id\n construct_room(r)\n end\n end\n end",
"def floor\n ru_floor_value = property_hash.get(\"Floor\").to_i\n return -1 if ru_floor_value == -1000\n return ru_floor_value\n end",
"def home\n check_medals()\n\n assert(current_user.kind_of?(User))\n \n return find_level(current_user.points)\n end",
"def decide_direction()\n floors = @building.floors\n requests_below = 0\n #see how many people below, wanting to go up or down\n (1..@current_floor).each do |floor_num|\n f = floors[floor_num]\n if f.button_pairs[\"elevator#{@number}\"][\"up\"] == true || f.button_pairs[\"elevator#{@number}\"][\"down\"] == true\n requests_below += f.up_person_queue.size() + f.down_person_queue.size()\n end\n end\n requests_above = 0\n #see how many above wanting to go down or up\n (@current_floor..@building.number_of_floors).each do |floor_num|\n f = floors[floor_num]\n if f.button_pairs[\"elevator#{@number}\"][\"down\"] == true || f.button_pairs[\"elevator#{@number}\"][\"up\"] == true\n requests_above += f.up_person_queue.size() + f.down_person_queue.size()\n end\n end\n if requests_above == 0 && requests_below == 0\n @direction = \"stationary\"\n elsif requests_above > requests_below\n @direction = \"up\"\n move_up()\n else #requests_above <= requests_below\n @direction = \"down\"\n move_down()\n end \n end",
"def set_floor_ammenity\n @floor_ammenity = Floor::Ammenity.find(params[:id])\n end",
"def index\n @workrooms = @floor ? @floor.workrooms : Workroom.all\n end",
"def show\n if params[:id]\n current_user # initialize @current_user\n\n @room = {\n \t:name => params[:id],\n \t:url => RTCHelper::getRoomURL(params[:id]),\n \t:token => RTCHelper::getAuthToken(params[:id], @current_user)\n }\n else\n #\n # if there is no room, we really wanted to go to /rooms/index\n #\n redirect_to :action => 'index'\n end\n end",
"def update\n @floor = Floor.find(params[:id])\n\n respond_to do |format|\n if @floor.update_attributes(params[:floor])\n format.html { redirect_to @floor, notice: 'Floor was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @floor.errors, status: :unprocessable_entity }\n end\n end\n end",
"def check_privilege(i = 0)\n floor_i = i.floor\n if floor_i == 1\n 'seller'\n elsif floor_i == 2\n 'manager'\n elsif floor_i >= 3\n 'admin'\n else\n 'user'\n end\nend",
"def index\n @floors = Floor.all.order('number ASC')\n authorize! :manage, Floor\n end",
"def create\n @floor = Floor.new(params[:floor])\n\n respond_to do |format|\n if @floor.save\n format.html { redirect_to @floor, notice: 'Floor was successfully created.' }\n format.json { render json: @floor, status: :created, location: @floor }\n else\n format.html { render action: \"new\" }\n format.json { render json: @floor.errors, status: :unprocessable_entity }\n end\n end\n end",
"def get_movement\n floor_difference = @current_floor - @requests_queue[0].floor\n if floor_difference > 0\n @movement = \"down\"\n else\n @movement = \"up\"\n end\n end",
"def openDoors(waitingTime)\n puts \" Opening doors...\"\n puts \" Elevator#{@id} doors are opened\"\n @elevatorDoor.status = DoorStatus::OPENED\n @floorDoorsList[@floor-1].status = DoorStatus::OPENED\n sleep(waitingTime)\n closeDoors\n end",
"def show\n @floor = Floor.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @floor }\n end\n end",
"def add_elevators(starting_floor, number_of_elevators)\n\t\tnumber_of_elevators.times do\n\t\t\te = Elevator.new(starting_floor, @elevator_strategy)\n\t\t\t@elevators << e\n\t\t\t@sim.register(e)\n\t\tend\n\tend",
"def update\n respond_to do |format|\n if @floor.update(floor_params)\n format.html { redirect_to floors_path, notice: I18n.t('floors.update') }\n format.json { render :show, status: :ok, location: @floor }\n else\n format.html { render :edit }\n format.json { render json: @floor.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_elevator_booking\n @elevator_booking = ElevatorBooking.find(params[:id])\n end",
"def find_nearest_elevator(elevator_direction, request_location)\n elevators = find_elevators_by_direction(elevator_direction)\n elevators.each { |elevator| elevator.distance_score = (request_location - elevator.current_floor).abs }\n return elevators.min { |a, b| a.distance_score <=> b.distance_score }\n end",
"def getelevators\n puts params\n elid = params[\"columnid\"]\n\n elevators = Elevator.where(:column_id => elid)\n\n puts elevators.inspect\n \n respond_to do |format|\n format.json { render json: elevators }\n end\n end",
"def current_company_floors(company_id)\n current_company_floors_ar = []\n company_offices_in_this_building = self.offices.where(company_id: company_id)\n company_offices_in_this_building.each do |office|\n current_company_floors_ar << office.floor\n end\n current_company_floors_ar\n end",
"def elevator_incidents\n @elevator_incidents ||= ElevatorIncident.get_by_station(self)\n end",
"def floor_params\n params.require(:floor).permit(:number, :name, :description, :colour)\n end",
"def collision_floor\n return unless state.dy <= 0 # return unless player is going down or is as far down as possible\n player_rect = [state.x, next_y, state.tile_size, state.tile_size] # definition of player\n\n # Runs through all the sprites on the field and finds all intersections between player's\n # bottom and the top of a rect.\n floor_collisions = state.world_collision_rects\n .find_all { |r| r[:top].intersect_rect?(player_rect, state.collision_tolerance) }\n .first\n\n return unless floor_collisions # performs following changes if a collision has occurred\n state.y = floor_collisions[:top].top # y of player is set to the y of the colliding rect's top\n state.dy = 0 # no change in y because the player's path is blocked\n end"
] |
[
"0.793773",
"0.7650569",
"0.7575021",
"0.74889666",
"0.74183387",
"0.7154896",
"0.7093107",
"0.7078495",
"0.70356715",
"0.6796759",
"0.6785355",
"0.6701571",
"0.6570387",
"0.65656316",
"0.6461453",
"0.6383427",
"0.6357844",
"0.634533",
"0.62568986",
"0.62568986",
"0.6230515",
"0.62163764",
"0.62025154",
"0.61409944",
"0.60824573",
"0.6047641",
"0.6028337",
"0.6007632",
"0.5980446",
"0.5926783",
"0.592455",
"0.5886737",
"0.5856406",
"0.58498466",
"0.5804714",
"0.5762822",
"0.57298696",
"0.57143575",
"0.57060885",
"0.5692431",
"0.5662744",
"0.5650532",
"0.5644466",
"0.5612835",
"0.5604949",
"0.5602734",
"0.557134",
"0.557134",
"0.5567916",
"0.55501467",
"0.55462736",
"0.5537577",
"0.5520589",
"0.55201644",
"0.55199665",
"0.5517036",
"0.5481898",
"0.546925",
"0.54631644",
"0.5454148",
"0.54323685",
"0.5391576",
"0.53794634",
"0.5365535",
"0.5364526",
"0.53638875",
"0.5362261",
"0.5348368",
"0.5344196",
"0.53411186",
"0.5329643",
"0.5329643",
"0.5327151",
"0.531314",
"0.5312155",
"0.53035074",
"0.5300597",
"0.52607626",
"0.52359",
"0.5235849",
"0.5232949",
"0.5220704",
"0.52201986",
"0.5216366",
"0.5213986",
"0.52117276",
"0.521045",
"0.5205719",
"0.5187519",
"0.51728255",
"0.51726186",
"0.51724064",
"0.51719296",
"0.51632977",
"0.5157985",
"0.5156099",
"0.5143338",
"0.513991",
"0.5127734",
"0.5121409"
] |
0.8025594
|
0
|
Sorting floor request list
|
def sortFloorList
if @direction == 'up'
@floorRequestList.sort!
elsif @direction == 'down'
@floorRequestList.sort!.reverse
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def sort_params; end",
"def sort_params; end",
"def sort_entries; end",
"def sort_requests_queue\n request = @requests_queue[0]\n get_movement()\n\n if @requests_queue.length() > 1\n\n if @movement == \"up\"\n # Sort the queue in ascending order\n @requests_queue.sort!\n\n # Push any request to the end of the queue that would require a direction change\n for request in @requests_queue do\n if request.floor < @current_floor || request.direction != @movement\n @requests_queue.append(@requests_queue.delete(request))\n end\n end\n\n elsif @movement == \"down\"\n # Sort the queue in descending order\n @requests_queue.sort!\n @requests_queue.reverse!\n\n # Push any request to the end of the queue that would require a direction change\n for request in @requests_queue do\n if request.floor > @current_floor || request.direction != @movement\n @requests_queue.append(@requests_queue.delete(request))\n end\n end\n end\n end\n end",
"def sort_entries=(_arg0); end",
"def sort_fields\n\t\t@params.each do |k,v|\n\t\t\t@sorting_weight.merge!({k => 5}) unless @sorting_weight.has_key? k\n\t\tend\t\t\t\n\t\t\n\t @sorting_weight = {\n\t\t\t:order => 10,\n\t\t\t:offset => 10,\n\t\t\t:limit => 10,\n\t\t\t:owner_id => -2,\n\t\t\t:okay => -1,\n\t\t\t:category_name => 1,\n\t\t\t:subcategory_name => 2,\n\t\t\t:tags => 3,\n\t\t\t:texts => 4\t\t\t \n\t\t}\n\t\tparams_arr = @params.sort{ |a,b| sorting_weight[a[0]] <=> sorting_weight[b[0]] }\n\t\t@params = OrderedHash.new\n\t\tparams_arr.each do |item|\n\t\t\t@params.merge! [item].to_h\n\t\tend\t\t\n\tend",
"def sort_params=(_arg0); end",
"def sort_params=(_arg0); end",
"def sort_floor_plans\n if presentable.available_floor_plans.in_group(group).map(&:position).any?{ |e| e.nil? }\n @plans = presentable.available_floor_plans.in_group(group).\n sort{|a,b| NaturalSort.comparator(a.name, b.name)}\n else\n @plans = presentable.available_floor_plans.in_group(group).order(:position)\n end\n end",
"def sort_request(request_type)\n request_type && abnamro? ? \"_#{request_type.to_s}\" : nil\n end",
"def tie_breaking_sort\n { \"content_id\" => { order: \"asc\" } }\n end",
"def sort\n params[:backlog_entry].each_with_index do |id, index|\n BacklogEntry.update_all({position: index+1}, {id: id})\n end\n render nothing: true\n end",
"def recognize_sort(input)\n sort_products = condition_sort(input[:requested])\n\n Success(sort_products)\n rescue StandardError\n Failure(Response::ApiResult.new(status: :internal_error, message: DB_ERR_MSG))\n end",
"def list_entries_with_sort\n if params[:sort].present? && sortable?(params[:sort])\n list_entries_without_sort.except(:order).order(sort_expression)\n else\n list_entries_without_sort\n end\n end",
"def get_sorting (default_sort_key)\n \n # Allowed sort fields, can sort by only these fields (are indexed) \n sort_keys = ['name', 'a_id', 'pub_id' , 'popularity_weight', 'category', \n 'sub_category', 'interests', 'release_date', \n 'total_ratings_count', 'total_average_rating',\n 'current_ratings_count', 'current_average_rating',\n 'new_apps', 'new_free_apps', 'new_paid_apps', \n 'top_free_apps_iphone', 'top_paid_apps_iphone',\n 'top_gros_apps_iphone', 'top_free_apps_ipad',\n 'top_paid_apps_ipad', 'top_gros_apps_ipad', 'amount',\n 'pub_name']\n \n # Get the sort_by parameter if it exists, otherwise use the default\n sort_param = request.query_parameters['sort_by'] || default_sort_key\n \n # Make sure the sort parameter is in our allowed list \n sort_key = sort_param if sort_keys.include?sort_param \n return sort_key\n \n end",
"def index\n @listings = Listing.order(params[:sort])\n end",
"def sort_input(input, property, order); end",
"def generate_sorted_by(request)\n\t\t# Sort the albums based on the \"order\" param from query string\n\t\torder = request.GET()[\"order\"]\n\t\tcase order\n\t\twhen \"rank\" then @albums.sort_by! { |album| album[@@COL_RANK] }\n\t\twhen \"name\" then @albums.sort_by! { |album| album[@@COL_NAME] }\n\t\twhen \"year\" then @albums.sort_by! { |album| album[@@COL_YEAR] }\n\t\telse @albums.sort_by! { |album| album[@@COL_RANK] }\n\t\tend\n\t\t# Return the HTML displaying the sort order\n\t\t\"<p>Sorted by #{order}</p>\"\n\tend",
"def sort_items\n @items = @items.sort_by(&:created_at) if params[:order] == 'date'\n @items = @items.sort_by(&:created_at).reverse if params[:order] == 'date desc'\n @items = @items.sort_by(&:payee) if params[:order] == 'payee'\n @items = @items.sort_by(&:payee).reverse if params[:order] == 'payee desc'\n @items = @items.sort_by(&:description) if params[:order] == 'descr'\n @items = @items.sort_by(&:description).reverse if params[:order] == 'descr desc'\n @items = @items.sort_by(&:amount) if params[:order] == 'saldo'\n @items = @items.sort_by(&:amount).reverse if params[:order] == 'saldo desc'\n @items = @items.sort_by(&:category_id) if params[:order] == 'cat'\n @items = @items.sort_by(&:category_id).reverse if params[:order] == 'cat desc'\n end",
"def alphabetailc_order\n @sorting_order = @data[\"prizes\"].sort_by{|a| a[\"year\"]}.group_by{|a| puts a[\"laureates\"].sort_by{|k| k[\"firstname\"]}}\n #@sorting_order = @data[\"prizes\"].sort_by { |a | [a[\"year\"],a[\"category\"]] }.sort_by{|a|}\n render :json => @sorting_order\n end",
"def stable_sort_by(list); end",
"def sort_record(response_refill_order)\n list =response_refill_order.pick(\"transferNo\" , \"createScan\" , \"shipDate\" , \"actualDate\" , \"recDate\" , \"status\" , \"poNo\" , \"custPN\" , \"ordQty\" , \"shipQty\" , \"controlNo\" , \"scancode\" , \"binCenter\" , \"binLoc\" , \"trackingNo\")\n response_list = {}\n response_list.compare_by_identity\n list[\"transferNo\"].each_with_index do |transferNo,index|\n response_list[transferNo] = {\n :createScan => list[\"createScan\"][index],\n :shipDate => list[\"shipDate\"][index],\n :actualDate => list[\"actualDate\"][index],\n :recDate => list[\"recDate\"][index],\n :status => list[\"status\"][index],\n :poNo => list[\"poNo\"][index],\n :custPN => list[\"custPN\"][index],\n :ordQty => list[\"ordQty\"][index],\n :shipQty => list[\"shipQty\"][index],\n :controlNo => list[\"controlNo\"][index],\n :scancode => list[\"scancode\"][index],\n :binCenter => list[\"binCenter\"][index],\n :binLoc => list[\"binLoc\"][index],\n :trackingNo => list[\"trackingNo\"][index]\n }\n end\n # COMMENTING FILTER FOR RECDATE AS PER ANTONIO'S FEEDBACK.\n response_list.delete_if {|_,v| v[:recDate] == \"Deleted\" || v[:recDate] == \"Bad fm Stk\" || v[:recDate] == \"Not Recvd\" || v[:recDate] == \"Cancelled\" || v[:recDate] == \"##\" }\n # response_list = Hash[response_list.sort.reverse]\n begin\n sorted_array = response_list.sort do |x,y|\n x <=> y || 0\n end.reverse\n response_hash = {}\n response_hash.compare_by_identity\n sorted_array.each_with_index { |value,key|\n response_hash[value[0]]= value[1]\n }\n rescue\n response_hash = {}\n end\n return response_hash\n end",
"def perform\n kahn_sorting if @sorted_list.empty?\n\n @sorted_list\n end",
"def sort_by(&block)\n super(&block).extend(OperationList)\n end",
"def index\n sort_group = [\"id\",\"realname\",\"vote_count\"];\n @sorted = {};\n sort_group.each do |x|\n @sorted[x.to_sym]=0\n end\n if !params[:sort_by].nil?\n sort(params[:sort_by],params[:sort_type])\n else\n @manage_users = Manage::User.all\n end\n\n end",
"def actionlist_sort(action, list)\n list\n end",
"def ordered(data)\n field, ordering = sanitize_ordering(data, field_suffix: :AT)\n\n dtf = params.dig(:query, :filter, :date_time_filter) || {}\n if (dtf.keys - [field]).any?\n raise SquareLite::MismatchedParams.new(sort_field: data, date_time_filter: dtf)\n end\n\n params.bury(:query, :sort, sort_field: field, sort_order: ordering)\n self\n end",
"def sort\n\t@events = @events.sort_by { | e | e.time_from_start }\n\trecalc_delta_from_times()\n end",
"def sort\n i = 0;\n list_orders = Hash[params[:list].to_a.map {|k| [k, i+=1]}]\n lists = Board.find(params[:board_id]).lists.order(:order)\n lists.each do |list|\n list.order = list_orders[list.id.to_s]\n list.save\n end\n render nothing: true\n end",
"def ordered_list; end",
"def sort(opts = {})\n return [] if not distkey\n \n opts[:by] = sortables[opts[:by]] if opts[:by]\n\n if opts[:start] && opts[:limit]\n opts[:limit] = [opts[:start], opts[:limit]]\n end\n\n objects(distkey.sort(opts))\n end",
"def sort_abschnitte_and_umschlaege\n abschnitt_umschlag_list = []\n # Hilfsmethode, baut einen nach Orten sortierten Hash auf.\n ort_to_detail = sort_abschnitte_and_umschlaege_by_ort\n File.open(\"log/transport.log\",\"w\"){|f| f.puts \"Ort to detail #{ort_to_detail}\" }\n unless self.start_anlage.nil?\n if self.start_anlage.ort\n ort_aktuell = self.start_anlage.ort\n if ort_aktuell.nil? || ort_to_detail[ort_aktuell.id].nil?\n ort_aktuell = abschnitt_only_start_ort(ort_to_detail.keys) \n end \n counter = 0\n while not (ort_aktuell.nil? || ort_to_detail.empty? || counter > 100)\n counter += 1\n next_ort = nil\n ort_aktuell_id = ort_aktuell.nil? ? 0 : ort_aktuell.id \n unless ort_to_detail[ort_aktuell_id].nil?\n ort_to_detail[ort_aktuell_id].each do |abschnitt_umschlag|\n File.open(\"log/transport.log\",\"a\"){|f| f.puts abschnitt_umschlag.attributes }\n abschnitt_umschlag_list << abschnitt_umschlag\n next_ort = abschnitt_umschlag.end_ort if abschnitt_umschlag.kind_of? Transportabschnitt \n end\n ort_to_detail.delete(ort_aktuell_id) \n ort_aktuell = next_ort\n end\n end \n # Rest nach Datum sortieren\n unless ort_to_detail.empty?\n File.open(\"log/transport.log\",\"a\"){|f| f.puts \"Rest nach Datum\" }\n abschnitt_umschlag_list = abschnitt_umschlag_list.concat(sort_abschnitte_and_umschlaege_by_date(ort_to_detail.values.flatten))\n end\n else \n #File.open(\"log/transport.log\",\"a\"){|f| f.puts \"Alles nach Datum\" }\n abschnitt_umschlag_list = abschnitt_umschlag_list.concat(sort_abschnitte_and_umschlaege_by_date(ort_to_detail.values.flatten))\n end \n end\n #File.open(\"log/transport.log\",\"a\"){|f| f.puts \"Transport #{id}: #{abschnitt_umschlag_list.to_s}\" }\n abschnitt_umschlag_list\n end",
"def sort\n params[:dept].each_with_index {|val, index|\n obj = Department.find_by_apikey(val)\n obj.update_attribute(:sort_order, index)\n }\n render :text => \"\"\n end",
"def sorted_results\n results.sort\n end",
"def sort_obj\n [@name, @version, Gem::Platform.sort_priority(@new_platform)]\n end",
"def bigSorting(unsorted)\n\nend",
"def convert_sort_params\n @sort_params = []\n #convert sort params to database columns\n if params[:sorting] && params[:sorting].is_a?(Array)\n params[:sorting].each do |p|\n\n sort = sort.reject{|k, v| !@resource.attribute_method?(k) || !['asc', 'desc'].include?(v.downcase)}\n\n @sort_params.push(sort)\n end\n end\n @sort_params\n end",
"def get_sort(collection, params)\n if params[:sort] && sort = cached_source(params[:sort])\n collection.joins(:results)\n .where(\"results.source_id = ?\", sort.id)\n .order(\"results.total DESC\")\n elsif params[:sort] == \"created_at\"\n collection.order(\"works.created_at ASC\")\n else\n collection.order(\"works.issued_at DESC\")\n end\n end",
"def sort_my_list\n @tracks.clear\n @artists.clear\n @genres.clear\n @user_list.each do |item|\n @tracks << item['id'] if item['type'] == 'track'\n @artists << item['id'] if item['type'] == 'artist'\n @genres << item['name'].downcase if item['type'] == 'genre'\n end\n end",
"def sort_by\n unless params[:sort].blank?\n params[:sort] if params[:sort] == 'created_at' || 'vote_score' || 'replies'\n else\n 'created_at'\n end\n end",
"def sorted_for_field(field)\n for_field(field).sort\n end",
"def ordering_query; end",
"def sort_results(results)\n case @metadata[:sort]\n when \"new\"\n results.sort_by do |c|\n [c.set.regular? ? 0 : 1, -c.release_date_i, c.default_sort_index]\n end\n when \"old\"\n results.sort_by do |c|\n [c.set.regular? ? 0 : 1, c.release_date_i, c.default_sort_index]\n end\n when \"newall\"\n results.sort_by do |c|\n [-c.release_date_i, c.default_sort_index]\n end\n when \"oldall\"\n results.sort_by do |c|\n [c.release_date_i, c.default_sort_index]\n end\n when \"cmc\"\n results.sort_by do |c|\n [c.cmc ? 0 : 1, -c.cmc.to_i, c.default_sort_index]\n end\n when \"pow\"\n results.sort_by do |c|\n [c.power ? 0 : 1, -c.power.to_i, c.default_sort_index]\n end\n when \"tou\"\n results.sort_by do |c|\n [c.toughness ? 0 : 1, -c.toughness.to_i, c.default_sort_index]\n end\n when \"rand\"\n results.sort_by do |c|\n [Digest::MD5.hexdigest(@query_string + c.name), c.default_sort_index]\n end\n when \"number\"\n results.sort_by do |c|\n [c.set.name, c.number.to_i, c.number, c.default_sort_index]\n end\n when \"color\"\n results.sort_by do |c|\n [COLOR_ORDER.fetch(c.colors), c.default_sort_index]\n end\n when \"ci\"\n results.sort_by do |c|\n [COLOR_ORDER.fetch(c.color_identity), c.default_sort_index]\n end\n when \"rarity\"\n results.sort_by do |c|\n [-c.rarity_code, c.default_sort_index]\n end\n else # \"name\" or unknown key\n results.sort_by(&:default_sort_index)\n end\n end",
"def sort_search_cases\n \t\t# sort the cases by latest, oldest and last week\n \t\tcases = case_list(params[:searchterm]).send(params[:sort_type])\n # check condition for cases is present or not.\n \t\tif cases.present?\n # response to the JSON\n render json: { success: true,response: cases.as_json('search') },:status=>200\n else\n render :json=> { success: false, message: \"Case is not present.\" },:status=> 203\n end\n \tend",
"def condition_sort(input)\n poke_name = input.poke_name\n product_db = SearchRecord::For.klass(Entity::Product)\n case input.sort\n when 'id'\n product_db.find_full_name(poke_name)\n when 'likes_DESC'\n product_db.order_by_desc_likes(poke_name)\n when 'likes_ASC'\n product_db.order_by_asc_likes(poke_name)\n when 'rating_DESC'\n product_db.order_by_desc_rating(poke_name)\n when 'rating_ASC'\n product_db.order_by_asc_rating(poke_name)\n when 'price_DESC'\n product_db.order_by_desc_price(poke_name)\n else\n # priceASC\n product_db.order_by_asc_price(poke_name)\n end\n end",
"def sort\n raise l(:priority_sort_no_project_error) if !parent_object\n \n @priorities = parent_object.priorities\n \n params.keys.select{|k| k.include? UL_ID }.each do |key|\n Priority.sort_priorities(@priorities, params[key])\n end\n \n render :nothing => true\n end",
"def sort_ops\n operations.running.sort_by { |op| sort_array(op) }.extend(OperationList)\n end",
"def index\n\n #the following sort order items are sorted by the model\n unless params[:id].nil?\n case true\n when params[:id] == \"model\"\n Classified.set_order_var( \" makes.name , models.name ASC \")\n @classifieds = Classified.available_sorted\n when params[:id] == \"stock_code\"\n Classified.set_order_var( params[:id] << \" ASC\")\n @classifieds = Classified.available_sorted\n when params[:id] == \"price_in_cents\"\n Classified.set_order_var( params[:id] << \" DESC\")\n @classifieds = Classified.available_sorted\n when params[:id] == \"colour\"\n Classified.set_order_var( params[:id] << \" ASC\")\n @classifieds = Classified.available_sorted\n when params[:id] == \"days_in_stock\"\n Classified.set_order_var( params[:id] << \" DESC \" )\n @classifieds = Classified.available_sorted\n when params[:id] == \"mileage\"\n Classified.set_order_var( params[:id] << \" DESC \" )\n @classifieds = Classified.available_sorted\n when params[:id] == \"views\" || params[:id] == \"forms_sent\" || params[:id] == \"conversions\"\n @classifieds = Classified.available\n end\n else\n Classified.set_order_var(\"\")\n @classifieds = Classified.available\n end\n\n\n #the following params[:id] values cause the array to be sorted as the values\n # to be sorted are added to the array programmatically\n unless params[:id].nil?\n case true\n when params[:id] == \"views\" \n @classifieds.sort! {|a, b| a.stats_count <=> b.stats_count}\n @classifieds.reverse!\n when params[:id] == \"forms_sent\"\n @classifieds.sort! {|a, b| a.form_count <=> b.form_count}\n @classifieds.reverse!\n when params[:id] == \"conversions\"\n @classifieds.sort! {|a, b| a.conversions.to_f <=> b.conversions.to_f}\n @classifieds.reverse!\n end\n end\n #@classifieds.reverse!\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @classifieds }\n end\n end",
"def manager_list_by_priority\n \n @sort_order = get_sort_order\n @sort_order[:priority] = params[:order] == 'ASC' ? 'DESC' : 'ASC'\n flash[:sort_order] = @sort_order\n\n design_reviews = get_active_reviews\n @active_reviews = design_reviews[:active].sort_by { |dr| [dr[:review].priority.value, dr[:review].age] }\n @inactive_reviews = design_reviews[:inactive].sort_by { |dr| [dr[:review].priority.value, dr[:review].age] }\n @active_reviews.reverse! if params[:order] == 'DESC'\n @inactive_reviews.reverse! if params[:order] == 'DESC'\n\n @submissions = BoardDesignEntry.submission_count\n session[:return_to] = {:controller => 'tracker',\n :action => 'manager_list_by_priority',\n :order => params[:order]}\n render( :action => 'manager_home' )\n\n end",
"def sort_abschnitte_and_umschlaege_by_ort\n ort_to_detail = {}\n self.umschlaege.each do |umschlag|\n ort = umschlag.ort\n ort_id = ort.nil? ? 0 : ort.id\n ort_to_detail[ort_id] ||= []\n ort_to_detail[ort_id] << umschlag\n end \n self.transportabschnitte.each do |abschnitt|\n ort = abschnitt.start_ort\n ort_id = ort.nil? ? 0 : ort.id\n ort_to_detail[ort_id] ||= []\n ort_to_detail[ort_id] << abschnitt\n end \n ort_to_detail\n end",
"def sort(collection)\n sort = params[:sort]\n return collection unless sort\n\n sort_fields = Jaf::SortFields.deserialize(sort)\n collection.order(sort_fields)\n end",
"def sort_params\n @_sort_params ||=\n if params[:sort].present?\n params[:sort].split(',').each_with_object({}) do |field, hash|\n unformatted_field = @request.unformat_key(field)\n desc, field = unformatted_field.to_s.match(/^([-_])?(\\w+)$/i)[1..2]\n hash[field.to_sym] = desc.present? ? :desc : :asc\n end\n end\n end",
"def set_listing_sort_order(search_object, default_val)\n if params[:sort]\n sort_order = params[:sort].downcase\n case sort_order\n when \"manu\"\n search_object.sort_order = SortOrder::SORT_BY_MANU_ASC\n when \"manud\"\n search_object.sort_order = SortOrder::SORT_BY_MANU_DESC\n when \"size\"\n search_object.sort_order = SortOrder::SORT_BY_SIZE_ASC\n when \"sized\"\n search_object.sort_order = SortOrder::SORT_BY_SIZE_DESC\n when \"upd\"\n search_object.sort_order = SortOrder::SORT_BY_UPDATED_ASC\n when \"updd\"\n search_object.sort_order = SortOrder::SORT_BY_UPDATED_DESC\n when \"qty\"\n search_object.sort_order = SortOrder::SORT_BY_QTY_ASC\n when \"type\"\n search_object.sort_order = SortOrder::SORT_BY_TYPE_ASC\n when \"treadd\"\n search_object.sort_order = SortOrder::SORT_BY_TREADLIFE_DESC\n when \"distance\"\n search_object.sort_order = SortOrder::SORT_BY_DISTANCE_ASC\n when \"cost\"\n search_object.sort_order = SortOrder::SORT_BY_COST_PER_TIRE_ASC\n when \"costd\"\n search_object.sort_order = SortOrder::SORT_BY_COST_PER_TIRE_DESC\n when \"name\"\n search_object.sort_order = SortOrder::SORT_BY_MODEL_NAME_ASC\n when \"named\"\n search_object.sort_order = SortOrder::SORT_BY_MODEL_NAME_DESC\n when \"store\"\n search_object.sort_order = SortOrder::SORT_BY_STORE_NAME_ASC\n when \"stored\"\n search_object.sort_order = SortOrder::SORT_BY_STORE_NAME_DESC\n else\n search_object.sort_order = default_val\n end\n else\n search_object.sort_order = default_val\n end\n end",
"def sort\n # Force back to page 1\n @page = 1\n @data_management_plans = paginate_response(results: search_filter_and_sort)\n render layout: false\n end",
"def sort\n @pokers.sort.reverse\n end",
"def sorted(tasks)\r\n tasks.sort_by {|task| task[\"priority\"]}\r\nend",
"def sort\r\n ContentImage.sort(params[:content_image])\r\n render :nothing => true\r\n end",
"def sort(key, opts={})\n cmd = \"SORT #{key}\"\n cmd << \" BY #{opts[:by]}\" if opts[:by]\n cmd << \" GET #{opts[:get]}\" if opts[:get]\n cmd << \" INCR #{opts[:incr]}\" if opts[:incr]\n cmd << \" DEL #{opts[:del]}\" if opts[:del]\n cmd << \" DECR #{opts[:decr]}\" if opts[:decr]\n cmd << \" #{opts[:order]}\" if opts[:order]\n cmd << \" LIMIT #{opts[:limit].join(' ')}\" if opts[:limit]\n cmd << \"\\r\\n\"\n write cmd\n multi_bulk_reply\n end",
"def sort\n @student_entities = StudentEntity.all\n @student_entities = @student_entities.sort_by { |stu| stu.created_at }\n render json: @student_entities, status: 200\n end",
"def sort_abschnitte_and_umschlaege_by_date start_liste\n abschnitt_umschlag_list = []\n mit_end_datum = start_liste.select{|element| element.end_datum }\n #File.open(\"log/transport.log\",\"a\"){|f| f.puts \"Mit Ende #{mit_end_datum.to_s}\" }\n abschnitt_umschlag_list.concat(mit_end_datum.sort_by{|element| element.end_datum} )\n ohne_end_datum = start_liste.select{|element| element.end_datum.nil? }\n #File.open(\"log/transport.log\",\"a\"){|f| f.puts \"Ohne Ende: #{ohne_end_datum.to_s}\" }\n abschnitt_umschlag_list.concat(ohne_end_datum)\n #File.open(\"log/transport.log\",\"a\"){|f| f.puts \"Liste bei Date #{abschnitt_umschlag_list.to_s}\" }\n abschnitt_umschlag_list\n end",
"def sort_it(list_, n)\n # Your code goes here\nend",
"def apply_sorting(chain)\n chain\n end",
"def sort_events(events)\n events.sort_by { |e| e['time'] }.reverse\nend",
"def sort\n @entries = DependencySorter.new(@entries).sorted_items\n end",
"def get_sort_opts(params)\n\tif(params[:sort].nil?)\n\t\treturn [['_id', 1]] # just sort on the id\n\telse\n\t\tfields = destringify_array(params[:sort])\n\n\t\tresult = []\n\t\tfields.each do |f|\n\t\t\tparts = f.split(\":\")\n\t\t\tif(parts.count != 1)\n\t\t\t\tif(parts[1].to_s == \"desc\")\n\t\t\t\t\tresult << [parts[0].to_s, -1]\n\t\t\t\telse\n\t\t\t\t\tresult << [parts[0].to_s, 1]\n\t\t\t\tend\n\t\t\telse\t\n\t\t\t\tresult << [f.to_s, 1]\n\t\t\tend\t\t\t\n\t\tend\n\t\treturn result\n\tend\nend",
"def ordering_params(params)\n # For example it retrieves a list of experiences in descending order of price.\n # Within a specific price, older experiences are ordered first\n #\n # GET /api/v1/experiences?sort=-price,created_at\n # ordering_params(params) # => \"price desc, created_at asc\"\n # Experience.order(\"price desc, created_at asc\")\n #\n ordering = []\n return join_params(ordering) unless params[:sort]\n\n ordering = params[:sort].split(',').each_with_object(ordering) do |attr, memo|\n sort_sign = (attr =~ /\\A[+-]/) ? attr.slice!(0) : \"+\"\n memo << \"#{attr} #{SIGN_OPDERS[sort_sign]}\"\n end\n join_params(ordering)\n end",
"def location_index_sorts(query:)\n [\n [\"name\", :sort_by_name.t],\n [\"created_at\", :sort_by_created_at.t],\n [(query&.flavor == :by_rss_log ? \"rss_log\" : \"updated_at\"),\n :sort_by_updated_at.t],\n [\"num_views\", :sort_by_num_views.t]\n ]\n end",
"def sort_params(params)\n Hash[params.sort]\n end",
"def process_sort_by\n case public_plans_params.fetch(:sort_by, 'featured')\n when 'created_at'\n 'plans.created_at desc'\n when 'title'\n 'TRIM(plans.title) asc'\n else\n 'plans.featured desc, plans.created_at desc'\n end\n end",
"def find_sorted_entries_by_timelimit(section, oldest,limit)\n # entries = record.send(section).any_of([:time.gt => e], [:start_time.gt => e]).limit(limit)\n entries = send(section).timelimit(oldest).limit(limit)\n now = Time.now\n recs = entries.to_a\n recs.sort! do |x, y|\n t1 = x.time || x.start_time || now.to_i\n t2 = y.time || y.start_time || now.to_i\n t2 <=> t1\n end\n recs\n end",
"def friend_requests \n self.friend_requests_as_receiver.sort_by{ |request| request.requestor.name }\n end",
"def sort_users\n if params[:sort_by].present?\n criteria = params[:sort_by]\n @users = if criteria == 'last_sign_in_at'\n @users.order('last_sign_in_at desc')\n elsif criteria == 'last_created_at'\n @users.order('created_at desc')\n else\n @users.order('created_at asc')\n end\n else # default sorting\n @users = @users.order('last_sign_in_at desc')\n end\n end",
"def order; end",
"def order; end",
"def sort_links\n resource_service.sortable_fields.collect do |key,value|\n \tlink_to key, params.dup.update(:sort => key), :class => ((params[:sort].to_s==key.to_s) ? 'current' : '')\n end.join(' | ')\n end",
"def sort_params\n return [] unless params['sort_by']\n\n orders = (params['sort_order'] ? params['sort_order'].split(\",\") : [\"\"])\n sort_order = params['sort_by'].split(\",\").zip(orders).collect do |attr, order|\n next if attr.blank?\n sort_item = attr\n sort_item << \" ASC\" if order && order.downcase.start_with?(\"asc\")\n sort_item << \" DESC\" if order && order.downcase.start_with?(\"desc\")\n sort_item\n end\n sort_order.compact\n end",
"def sort\n raise l(:todo_sort_no_project_error) if !parent_object\n \n #@todos = Todo.for_project(@project.id)\n @todos = parent_object.todos\n \n params.keys.select{|k| k.include? UL_ID }.each do |key|\n Todo.sort_todos(@todos,params[key])\n end\n \n render :nothing => true\n #render :action => \"sort.rjs\"\n end",
"def sort_requirement\n find_user\n if !@user.nil?\n assign_project\n\n if params[:name]==\"created_at\"\n @requirements=Requirement.find(:all, :conditions=>[\"project_id=?\", session[:project_id]], :order => \"#{params[:name]} desc\")\n else\n @requirements=Requirement.find(:all, :conditions=>[\"project_id=?\", session[:project_id]], :order => \"#{params[:name]}\")\n end\n @attr=Attribute.find_by_project_id(session[:project_id])\n end\n end",
"def sort\n conditions = scope_condition\n list_items = order_by_position(conditions, :created_at.desc).to_a\n\n list_items.each_with_index do |list_item, index|\n list_item.set_my_position index + 1\n end\n end",
"def sort\n conditions = scope_condition\n list_items = order_by_position(conditions, :created_at.desc).to_a\n\n list_items.each_with_index do |list_item, index|\n list_item.set_my_position index + 1\n end\n end",
"def order_collection!\n sort_field = (params[:sort] || '').underscore\n sort_direction_key = (params[:sortDirection] || '').downcase\n sort_direction = SortDirection::LIST[sort_direction_key]\n return if sort_field.blank? || sort_direction.blank?\n\n self.collection = collection.order(\n sort_field => sort_direction\n )\n end",
"def sort_operations\n operations.sort! { |a, b| sort_list(b, a) <=> sort_list(a, b) }\n end",
"def sort_times\n @links.each_value { |l| l.sort_times }\n end",
"def sorting_logic\n if params[:sort_by] == \"score\"\n @reviews = @city.department_reviews.sort_by { |dr| dr.score }\n @reviews.reverse!\n render action: :index\n elsif params[:sort_by] == \"date\"\n @reviews = @city.department_reviews.order('created_at DESC')\n render action: :index\n elsif params[:sort_by] == \"endorsements\"\n @reviews = @city.department_reviews.sort_by { |dr| dr.votes_for.size }\n @reviews.reverse!\n render action: :index\n elsif params[:sort_by] == \"comments\"\n @reviews = @city.department_reviews.sort_by { |dr| dr.count_comments }\n @reviews.reverse!\n render action: :index\n elsif params[:sort_by] == \"trending\"\n @reviews = @city.department_reviews.sort_by { |dr| dr.hits }\n @reviews.reverse!\n render action: :index\n else \n @reviews = @city.department_reviews.sort_by { |dr| dr.hits }\n @reviews.reverse!\n render action: :index\n end \n end",
"def sorting\n @records = Record.all #Get existing records\n @sortType = params[:sortType] #Get parameters from the form on index\n @sortField = params[:sortField]\n\n @limit = params[:sortNum].to_i # params must be converted from string\n\n if @sortType == \"Decending\" # check if sort direction is decending\n case @sortField #check what header to sort by\n when \"id\" # when table header is ID sort by ID descending\n @sortedSet = Record.order(id: :desc).limit(@limit)\n when \"REF_DATE\"\n @sortedSet = Record.order(REF_DATE: :desc).limit(@limit)\n when \"GEO\"\n @sortedSet = Record.order(GEO: :desc).limit(@limit)\n when \"DGUID\"\n @sortedSet = Record.order(DGUID: :desc).limit(@limit)\n when \"Sex\"\n @sortedSet = Record.order(Sex: :desc).limit(@limit)\n when \"Age_group\"\n @sortedSet = Record.order(Age_group: :desc).limit(@limit)\n when \"Student_response\"\n @sortedSet = Record.order(Student_response: :desc).limit(@limit)\n when \"UOM\"\n @sortedSet = Record.order(UOM: :desc).limit(@limit)\n when \"UOM_ID\"\n @sortedSet = Record.order(UOM_ID: :desc).limit(@limit)\n when \"SCALAR_FACTOR\"\n @sortedSet = Record.order(SCALAR_FACTOR: :desc).limit(@limit)\n when \"SCALAR_ID\"\n @sortedSet = Record.order(SCALAR_ID: :desc).limit(@limit)\n when \"VECTOR\"\n @sortedSet = Record.order(VECTOR: :desc).limit(@limit)\n when \"COORDINATE\"\n @sortedSet = Record.order(COORDINATE: :desc).limit(@limit)\n when \"VALUE\"\n @sortedSet = Record.order(VALUE: :desc).limit(@limit)\n when \"STATUS\"\n @sortedSet = Record.order(STATUS: :desc).limit(@limit)\n when \"SYMBOL\"\n @sortedSet = Record.order(SYMBOL: :desc).limit(@limit)\n when \"TERMINATED\"\n @sortedSet = Record.order(TERMINATED: :desc).limit(@limit)\n when \"DECIMALS\"\n @sortedSet = Record.order(DECIMALS: :desc).limit(@limit)\n \n end # end case/when\n else # if not decending its ascending\n case @sortField # check header to sort by\n when \"id\" # when table header is ID sort by ID ascending\n @sortedSet = Record.order(id: :asc).limit(@limit)\n when \"REF_DATE\"\n @sortedSet = Record.order(REF_DATE: :asc).limit(@limit)\n when \"GEO\"\n @sortedSet = Record.order(GEO: :asc).limit(@limit)\n when \"DGUID\"\n @sortedSet = Record.order(DGUID: :asc).limit(@limit)\n when \"Sex\"\n @sortedSet = Record.order(Sex: :asc).limit(@limit)\n when \"Age_group\"\n @sortedSet = Record.order(Age_group: :asc).limit(@limit)\n when \"Student_response\"\n @sortedSet = Record.order(Student_response: :asc).limit(@limit)\n when \"UOM\"\n @sortedSet = Record.order(UOM: :asc).limit(@limit)\n when \"UOM_ID\"\n @sortedSet = Record.order(UOM_ID: :asc).limit(@limit)\n when \"SCALAR_FACTOR\"\n @sortedSet = Record.order(SCALAR_FACTOR: :asc).limit(@limit)\n when \"SCALAR_ID\"\n @sortedSet = Record.order(SCALAR_ID: :asc).limit(@limit)\n when \"VECTOR\"\n @sortedSet = Record.order(VECTOR: :asc).limit(@limit)\n when \"COORDINATE\"\n @sortedSet = Record.order(COORDINATE: :asc).limit(@limit)\n when \"VALUE\"\n @sortedSet = Record.order(VALUE: :asc).limit(@limit)\n when \"STATUS\"\n @sortedSet = Record.order(STATUS: :asc).limit(@limit)\n when \"SYMBOL\"\n @sortedSet = Record.order(SYMBOL: :asc).limit(@limit)\n when \"TERMINATED\"\n @sortedSet = Record.order(TERMINATED: :asc).limit(@limit)\n when \"DECIMALS\"\n @sortedSet = Record.order(DECIMALS: :asc).limit(@limit) \n end\n end\n \n end",
"def sort_order\n 10 - object.id\n end",
"def sort_if_needed(deliverables)\n if session[@sort_name] && %w(score spent progress labor_budget).include?(session[@sort_name][:key])\n case session[@sort_name][:key]\n when \"score\" then\n sorted = deliverables.sort {|a,b| a.score <=> b.score}\n when \"spent\" then\n sorted = deliverables.sort {|a,b| a.spent <=> b.spent}\n when \"progress\" then\n sorted = deliverables.sort {|a,b| a.progress <=> b.progress}\n when \"labor_budget\" then\n sorted = deliverables.sort {|a,b| a.labor_budget <=> b.labor_budget}\n end\n\n return sorted if session[@sort_name][:order] == 'asc'\n return sorted.reverse! if session[@sort_name][:order] == 'desc'\n else\n return deliverables\n end\n end",
"def sort_by_alg_header(algs); end",
"def sortby_callnum solr_parameters, user_parameters\n if user_parameters[:search_field] == 'call number'\n callnum_sortby = blacklight_config.sort_fields.values.select { |field| field.callnum_default == true }.first\n solr_parameters[:sort] = callnum_sortby.field\n end\n end",
"def sort_and_group\n @customer_sort_field = validate_sort_field( @customer_sort_field )\n @project_sort_field = validate_sort_field( @project_sort_field )\n @task_sort_field = validate_sort_field( @task_sort_field )\n\n @filtered_tasks.sort! do | task_a, task_b |\n complex_sort(\n task_a,\n task_b,\n {\n :group_by_billable => ( @task_grouping == 'billable' || @task_grouping == 'both' ),\n :group_by_active => ( @task_grouping == 'active' || @task_grouping == 'both' ),\n :customer_sort_field => @customer_sort_field,\n :project_sort_field => @project_sort_field,\n :task_sort_field => @task_sort_field\n }\n )\n end\n end",
"def sort_data\n store.sort_data!\n end",
"def lbSort _args\n \"lbSort _args;\" \n end",
"def index\n # @day_road_lists = DayRoadList.all.sort_by(&:day)\n @day_road_lists = DayRoadList.all.order(day: :asc)\n end",
"def incomplete_list(sort_order: { created_at: :desc })\n incomplete.order(sort_order)\n end",
"def sorted_versions(versions)\n versions.blank? ? [] : versions.map { |val| val['number'] }.version_sort\nend",
"def sort_conditions\n @sort_conditions ||= SimpleTypedList.new SortCondition\n end",
"def set_sort_order\n object = params[:imageable_type].constantize.find(params[:imageable_id])\n uploads = object.uploads\n params[:order].each_pair do |key, value|\n uploads.find(value[:id]).update_columns(sort: key, updated_at: Time.now)\n end\n render json: { message: 'success' }, :status => 200\n end",
"def get_sorted_list(type)\n temp_array = @items.select { |item| item.instance_of?(type) }\n case type\n when TodoItem\n temp_array.sort! { |i, j| i.due.to_s <=> j.due.to_s }\n when EventItem\n temp_array.sort! { |i, j| i.start_date.to_s <=> j.start_date.to_s }\n when LinkItem\n temp_array.sort! { |i, j| i.site_name <=> j.site_name }\n end\n temp_array\n end",
"def sort sortfield = :id, descending = false\n @sortfield = sortfield.to_sym\n reverse = descending ? -1 : 1\n @data = @data.compact.sort { |us1, us2|\n comp =\n if us1[@sortfield] && us2[@sortfield]\n us1[@sortfield] <=> us2[@sortfield]\n elsif us1[@sortfield]\n 1\n elsif us2[@sortfield]\n -1\n else\n 0\n end\n comp * reverse\n }\n end",
"def getSortingOrder #:doc:\n sorting = @default_sorting.dup\n ordering = [\"DESC\", \"ASC\", \"ASC\", \"ASC\"] # default ordering\n \n if @queryparams[:sort_by]\n # get given sort_by-values\n sorts = @queryparams[:sort_by].split(\" \")\n # get given order-values and make sure sorts.size == orders.size\n orders = Array.new(sorts.size, \"DESC\")\n if @queryparams[:order]\n orders = @queryparams[:order].split(\" \")\n if orders.size < sorts.size\n orders += Array.new(sorts.size - orders.size, \"DESC\")\n elsif orders.size > sorts.size\n orders = orders.slice(0, sorts.size)\n end\n orders.each do |o|\n if not (o.upcase == \"ASC\" or o.upcase == \"DESC\") then o = \"ASC\" end\n end \n end\n \n # first sort_by-value has to be processed last (so it gets first on the list)\n sorts = sorts.reverse\n orders = orders.reverse\n \n # check sort_by-values\n sorts.each_index do |i|\n if @sort_by.has_key?(sorts[i])\n # move the sort-attribute to first\n sort_value = @sort_by[sorts[i]]\n ind = sorting.index(\"LOWER(\" + @sort_by[sorts[i]] + \")\")\n if ind != nil\n sorting.delete_at(ind)\n ordering.delete_at(ind)\n sort_value = \"LOWER(\" + sort_value + \")\"\n end\n sorting.unshift(sort_value)\n ordering.unshift(orders[i].upcase)\n end\n end\n end\n \n #combine everything together\n returnable = sorting[0] + \" \" + ordering[0]\n sorting.each_index do |i|\n next if i == 0\n returnable += \", \" + sorting[i] + \" \" + ordering[i]\n end\n return returnable\n end"
] |
[
"0.68617064",
"0.68617064",
"0.6753194",
"0.6752096",
"0.6388564",
"0.6361775",
"0.6293843",
"0.6293843",
"0.6278227",
"0.62235636",
"0.6135104",
"0.6038651",
"0.59794766",
"0.597288",
"0.5957384",
"0.5868069",
"0.58595574",
"0.58451015",
"0.58067507",
"0.579388",
"0.57817155",
"0.57799375",
"0.57759726",
"0.57665354",
"0.5752814",
"0.5732718",
"0.571345",
"0.5704385",
"0.57042795",
"0.5694267",
"0.56686944",
"0.5641186",
"0.56370234",
"0.56367207",
"0.56349015",
"0.56232685",
"0.5621599",
"0.56125784",
"0.5611655",
"0.5609097",
"0.5603976",
"0.56026816",
"0.55997664",
"0.5593991",
"0.55910546",
"0.5577169",
"0.55765563",
"0.5554419",
"0.5545246",
"0.5543324",
"0.554108",
"0.55403733",
"0.5533673",
"0.55302495",
"0.552998",
"0.55253786",
"0.5509743",
"0.54929584",
"0.5492445",
"0.54886717",
"0.5485006",
"0.548049",
"0.5479689",
"0.5473024",
"0.5470698",
"0.54703337",
"0.54669476",
"0.5464381",
"0.5464148",
"0.5464046",
"0.54633117",
"0.5456627",
"0.54509157",
"0.54509157",
"0.5445912",
"0.54442537",
"0.5438403",
"0.5437524",
"0.54359937",
"0.54359937",
"0.5435179",
"0.5434218",
"0.5425601",
"0.54210687",
"0.54193956",
"0.5416031",
"0.5412482",
"0.5409375",
"0.53989524",
"0.53968054",
"0.5394059",
"0.5393992",
"0.53928894",
"0.53926414",
"0.5392343",
"0.53893316",
"0.5388722",
"0.5387589",
"0.53790516",
"0.53782743"
] |
0.79077053
|
0
|
num1 First number. num2 Second number. num3 Third number. Examples min_of_three(7,12,2) => 2 Returns smallest of three numbers.
|
def min_of_three(num1, num2, num3)
if num1 < num2
if num1 < num3
return num1
end
else
if num2 < num3
return num2
end
end
return num3
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def min_of_three(min,num2,num3)\n if min > num2\n min = num2\n end\n if min > num3\n min = num3\n end\n return min\nend",
"def min_of_three(num1, num2, num3)\n if num1 < num2 and num1 < num3\n return num1\n end\n if num2 < num1 and num2 < num3\n return num2\n end\n return num3\nend",
"def min_of_three(min,num2,num3,num4)\n if min > num2\n min = num2\n end\n if min > num3\n min = num3\n end\n if min > num4\n min = num4\n end\n return min\nend",
"def min_of_three(num1, num2, num3)\n if num1 < num2 && num1 < num3\n return num1\n elsif num2 < num1 && num2 < num3\n return num2\n else\n return numm3\n end\nend",
"def minofthree(num1, num2, num3)\n if num1 > num2\n i = num2\n else \n i = num1\n end\n if num3 < i \n i = num3\n end\n return i\nend",
"def min_of_three(num1,num2,num3)\n if num1 < num2\n smaller = num1\n else\n smaller = num2\n end\n\n if smaller < num3\n return smaller\n else\n return num3\n end\nend",
"def minofthree(num1, num2, num3)\n if num1 < num2\n if num1 < num3\n return num1\n else\n return num3\n end\n else\n if num2 < num3\n return num2\n else\n return num3\n end\n end\nend",
"def min(num1, num2, num3)\n if num1 <= num2 and num1 <= num3\n return num1\n elsif num2 <= num1 and num2 <= num3\n return num2\n else\n return num3\n end\nend",
"def smallest_one(num1,num2,num3)\n if num1 < num2 && num1 < num3\n num1\n elsif num2 < num1 && num2 < num3\n num2\n else num3 < num1 && num3 < num1\n num3\n end\nend",
"def min_of_three(num1, num2, num3)\n \n biggest = 0\n if num1 < num2 \n biggest = num2\n else \n biggest = num1\n end\n\n if biggest < num3\n return num3\n else \n return biggest\n end\nend",
"def smallest_number(number1,number2,number3)\n\tif number1<number2 and number1<=number3\n\t\treturn number1\n\telsif number2<number3 and number2<=number1\n\t\treturn number1\n\telse \n\treturn number3\n\tend\nend",
"def min_of_three(n1, n2, n3)\n output =\"\"\n if n1 < n2\n output = n1\n else\n output =n2\n end\n if output < n3\n return output\n else \n return n3\n end\nend",
"def min_of_three(siffra1, siffra2, siffra3)\n output = nil\n if siffra1 < siffra2\n output = siffra1\n else\n output = siffra2\n end\n if siffra3 < output\n output = siffra3\n end\n return output\n\nend",
"def min_of_four(num1, num2, num3, num4)\n min1 = num1\n min2 = num3\n if min1 > num2\n min1 = num2\n end\n if min2 > num4\n min2 = num4\n end\n if min1 > min2\n min = min2\n else\n min = min1\n end\n return min\nend",
"def min_of_four(min,num2,num3,num4)\n if min > num2\n min = num2\n end\n if min > num3\n min = num3\n end\n if min > num4\n min = num4\n end\n\n return min\nend",
"def min_of_three(term1, term2, term3)\n\n small = term2\n if term1 < small\n small = term1\n end\n \n if small > term3\n small = term3\n end\n return small\nend",
"def min_of_three(num1, num2, num3)\n array = [num1, num2, num3]\n i = 0\n output = num1\n while i < array.length\n if array[i] < output\n output = array[i]\n end\n i +=1\n end\n return output\nend",
"def smallest_number(num1, num2)\n numbers = num1, num2\n return numbers.min\nend",
"def min3(a, b, c)\n if a < b && a < c\n a\n elsif b < c\n b\n else\n c\n end\n end",
"def smallest_number(num1, num2)\n\t[num1, num2].min\nend",
"def smallest_number n1, n2\n [n1, n2].min\nend",
"def min_of_four(n1, n2, n3, n4)\n smallest1 = n1\n smallest2 = n3\n\n if n2 < smallest1\n smallest1 = n2\n end\n if n4 < smallest2\n smallest2 = n4\n end\n if smallest2 < smallest1\n smallest1 = smallest2\n end\n return smallest1\nend",
"def smallest_number num1,num2\n\t[num1, num2].min\nend",
"def smallest_number(num1, num2)\n result = [num1, num2].min\n return result\nend",
"def min_of_four(number1, number2, number3, number4)\n output = number1\n if output > number2\n output = number2\n end\n if output > number3\n output = number3\n end\n if output > number4\n output = number4\n end\n return output\nend",
"def smallest_number num1, num2 \n\tif num1 < num2 \n\t\treturn num1\n\telsif num2 < num1 \n\t\treturn num2\n\tend\nend",
"def smallest_of_four(num1, num2, num3,num4)\n output= num1\n if num1>num2\n output=num2\n end\n if output> num3\n output=num3\n end\n if output>num4 \n output= num4\n end\n return output\nend",
"def smallest_number num1, num2\n if num1 < num2\n num1\n else\n num2\n end\nend",
"def min_3(x, y, z)\n if x < y and x < z\n x\n elsif y < x and y < z\n y\n else\n z\n end\n end",
"def smallest_number num1,num2\n if num1<num2\n return num1\n end\n num2\nend",
"def smallest_number num1, num2\n\tarrayNumbers = [num1, num2]\n\treturn arrayNumbers.min\nend",
"def min_3(x, y, z)\nend",
"def minimum( *numbers )\n min = numbers.first\n numbers.each { |number| min = number if number < min }\n min\nend",
"def minimum( *numbers )\n min = numbers.first\n numbers.each { |number| min = number if number < min }\n min\nend",
"def min_four(num1, num2, num3, num4)\n\n if num1 > num2\n output1 = num1\n else\n output1 = num2\n end\n\n if num3 > num4\n output2 = num3\n else\n output2 = num4\n end\n\n if output1 > output2\n return output1\n else\n return output2\n end\nend",
"def smallest_integer(list_of_nums)\n p list_of_nums.min\nend",
"def max_of_three num1, num2,num3\n if num1>num2 && num1> num3\n num1\n elsif num2>num1 && num2>num3\n num2\n end\n num3\nend",
"def max_of_three num1, num2, num3\n\tif num1 > num2 && num1 > num3\n\t\treturn num1\n\telsif num2 > num1 && num2 > num3\n\t\treturn num2\n\telsif num3 > num1 && num3 > num2\n\t\treturn num3\n\tend\n\nend",
"def smallest_integer(list_of_nums)\n\tans = list_of_nums.min \nend",
"def smallest_integer(list_of_nums)\n p list_of_nums.min\nend",
"def minoffour(num1, num2, num3, num4)\n if num1 > num2\n i = num2\n else \n i = num1\n end\n if num3 < i \n i = num3\n end\n if num4 < i\n i = num4\n end\n return i\nend",
"def minoftwo(num1, num2)\n if num1 > num2\n i = num2\n else \n i = num1\n end\n return i\nend",
"def max_of_three(num1,num2,num3)\n return num1 if num1 > num2 && num1 > num3\n return num2 if num2 > num1 && num1 > num3 \n return num3\nend",
"def max_of_three(num1, num2, num3)\n return num1 if num1 > num2 && num1 > num3\n return num2 if num2 > num3 && num2 > num1\n return num3\nend",
"def my_min(list)\n smallest_num = nil\n list.each do |num|\n if smallest_num == nil || smallest_num > num\n smallest_num = num\n end\n end\n smallest_num\nend",
"def min_of_two(num1, num2)\n if num1 < num2\n return num1\n end\n return num2\nend",
"def max_of_three num1, num2, num3\n # if num1 < num2\n # num1, num2 = num2, num1\n # end\n # if num1 < num3\n # num1, num3 = num3, num1\n # end\n # num1\n [num1, num2, num3].max\nend",
"def smallest_integerv2(list_of_nums)\n # Your code goes here!\n\treturn list_of_nums.min\nend",
"def minoffour(num1, num2, num3, num4)\n if num1 < num2 and num1 < num3 and num1 < num4\n return num1\n end\n if num2 < num1 and num2 < num3 and num2 < num4\n return num2\n end\n if num3 < num1 and num3 < num2 and num3 < num4\n return num3\n end\n if num4 < num1 and num4 < num2 and num4 < num3\n return num4\n end\nend",
"def min_of_two(number1,number2)\n if number1 < number2\n output = number1\n else\n output = number2\n end\n return output\nend",
"def min_of_two(number1, number2)\n if number1 < number2\n output = number1\n else\n output = number2\n end\n return output\nend",
"def smallest_integer(list_of_nums)\n smallest = nil\n list_of_nums.each do |num|\n if smallest == nil\n smallest = num\n end\n if num <= smallest\n smallest = num\n end\n end\n smallest\nend",
"def min_of_two(num1, num2)\n if num1 > num2\n return num2\n else return num1\n end\nend",
"def min_of_two(num, num2)\n if num < num2\n return num\n end\n return num2\nend",
"def max_of_three(max,num2, num3)\n if max < num2\n max = num2\n end\n if max < num3\n max = num3\n end\n return max\nend",
"def min_of_two(num1, num2)\n if num1 >= num2\n output = num2\n else output = num1\n end\n return output\nend",
"def my_min_2(list)\n min = nil\n\n list.each do |num|\n min = num if min.nil? || num < min\n end\n\n min\nend",
"def max_of_three(num1,num2,num3)\n if max_of_two(num1,num2) <= num3\n return num3\n end\n return max_of_two(num1,num2)\nend",
"def min_of_two(num1, num2)\n output = num1\n if num1 > num2\n output = num2 \n end\n return output\nend",
"def max_of_three(num1, num2, num3)\n numbers = num1, num2, num3\n return numbers.max\nend",
"def max(num1, num2, num3) \n\tif num1 >= num2 and num1 >= num3\n\t\treturn num1\n\telsif num2 >= num1 and num2 >= num3\n\t\treturn num2\n\telse\n\t\treturn num3\n\tend\nend",
"def find_min(*nums)\n nums.reduce do | acc, current_value |\n if acc > current_value\n current_value\n else\n acc\n end\n end\nend",
"def sum_two_smallest_numbers(numbers)\n numbers.min(2).reduce(:+)\nend",
"def min_of_two(number1, number2)\n return number1 if number1 < number2\n return number2\nend",
"def min_of_two(num1, num2)\n return num1 if num1 < num2\n return num2\nend",
"def max_of_three(num1, num2, num3)\n output = 0\n if num1 > num2 and num1 > num3\n output = num1\n elsif num2 > num3 and num2 > num1\n output = num2\n else\n output = num3\n end\n return output\nend",
"def max(num1, num2, num3)\n if num1 >= num2 and num1 >= num3\n return num1\n elsif num2 >= num1 and num2 >= num3\n return num2\n else\n return num3\n \n end\nend",
"def min_of_two(n1, n2)\n if n1 < n2\n return n1\n else\n return n2\n end\nend",
"def smallest_integer(list_of_nums)\n\tsmallest_num = list_of_nums[0]\n\tif list_of_nums.empty? == true\n\t\treturn nil\n\telse list_of_nums.each do |num|\n\t\tif num < smallest_num\n\t\t\tsmallest_num = num\n\t\tend\n\t\tend\n\tend\n\treturn smallest_num\nend",
"def max_of_three(num1, num2, num3)\n largest = 0\n if num1 > num2\n largest = num1\n else \n largest = num2\n end\n\n if num3 > largest\n return num3\n else\n return largest\n end\nend",
"def max(num1, num2, num3)\r\n if num1 >= num2 && num1 >= num3\r\n return num1\r\n elsif num2 >= num1 && num2 >= num3\r\n return num2\r\n else\r\n return num3\r\n end\r\nend",
"def smallest_integer(list_of_nums)\n length = list_of_nums.length\n if length == 0\n return nil\n else\n list_of_nums.min\n end\nend",
"def my_min2(list)\n smallest_number = list.first\n list.each do |num|\n smallest_number = num if num <= smallest_number\n end\n smallest_number\nend",
"def max_of_three(num1, num2, num3)\n\t[num1, num2, num3].max\nend",
"def Min_of_Two(number1,number2)\n if number1 > number2\n output = number2\n else\n output = number1\n end\n return output\nend",
"def min_of_two(n1, n2)\n smallest = n1\n if smallest > n2\n smallest = n2\n end\n return smallest\nend",
"def smallest_integer(list_of_nums)\n # Your code goes here!\n\tsmall = list_of_nums[0]\n\tlist_of_nums.each do |x|\n\t\tsmall = x if x < small\n\tend\n\treturn small\nend",
"def max_of_three num1,num2,num3\n\t[num1, num2, num3].max\nend",
"def smallest_integer(list_of_nums)\n smallest_num = list_of_nums[0]\n list_of_nums.each do |value|\n smallest_num = value if value < smallest_num\n end\n smallest_num\nend",
"def max(num1, num2, num3)\n if (num1 >= num2) && (num1 >= num2)\n return num1\n elsif (num2 >= num1) && (num2 >= num3)\n return num2\n else \n return num3\n end \nend",
"def smallest_integer(list_of_nums)\n smallest = list_of_nums[0]\n list_of_nums.each do |x|\n if x <= smallest\n smallest = x\n end\n end\n if list_of_nums.nil?\n return nil\n end\n return smallest\nend",
"def smallest_integer(list_of_nums)\n # Your code goes here!\n if list_of_nums == []\n \treturn nil\n else \n \tcurrent_smallest = list_of_nums[0]\n \tfor num in list_of_nums\n \t\tif num < current_smallest\n \t\t\tcurrent_smallest = num\n \t\tend\n \tend\n end\n puts \"The smallest number is #{current_smallest}\"\n return current_smallest\nend",
"def min_of_two(num1, num2)\n if num1 > num2\n return num1\n elsif num1 == num2\n return \"They are the same number\"\n else\n return num2\n end\nend",
"def my_min_2(list)\n min = list.first\n list.each do |num|\n if num < min \n min = num\n end\n end\n min\nend",
"def find_smallest_int(nums)\n max = nums[0]\n min = nums[0]\n nums.each do |item|\n if item > max\n max = item;\n elsif item < min\n min = item\n end \n end \n return min\nend",
"def smallest_integer(list_of_nums)\r\n smallest = list_of_nums.first\r\n list_of_nums.each {|n| smallest = n if n < smallest}\r\n return smallest\r\nend",
"def max_of_three(n1, n2, n3)\n largest = n1\n if n1 < n2\n largest = n2\n end\n if largest < n3\n largest = n3\n end\n return largest\nend",
"def smallest_integer(list_of_nums)\n return nil if list_of_nums.empty?\n smallest = list_of_nums.pop\n list_of_nums.each {|x| smallest = x if x < smallest }\n smallest\nend",
"def max(num1,num2,num3)\n if num1>num2 and num1>num3\n return num1\n elsif num2>num1 and num2>num3\n return num2\n elsif num3>num1 and num3>num2\n return num3\n end\nend",
"def find_smallest_num(arr)\n\treturn arr.min()\nend",
"def sum_two_smallest_numbers(numbers)\n #Your code here\n numbers.select(&:positive?).min(2).reduce(:+)\nend",
"def min_int(in_first, in_second)\n\tcheck_pre(((in_first.int?) and (in_second.int?)))\n\t(in_first > in_second ? in_second : in_first)\nend",
"def min_of_two(n1, n2)\n if n1 <= n2\n return n1\n else \n return n2\n end\nend",
"def lowest_product(input)\n if input.length < 4\n \"Number is too small\"\n else\n a = input.split(\"\").sort\n a.map! { |n| n.to_i }\n product = 1\n a[0..3].each { |n| product *= n }\n p product\n end\nend",
"def smallest(a, b)\n\ta < b ? a : b\nend",
"def max_of_three(num1, num2, num3)\n result = [num1, num2, num3].max\n return result\nend",
"def my_min_2(list)\n smallest = 0\n list.each do |el|\n smallest = el if el < smallest\n end\n smallest\nend",
"def smallest_integer(list_of_nums)\n small = list_of_nums[0]\n list_of_nums.each do |num|\n if num < small\n small = num\n end\n end\nsmall\nend",
"def max_of_three(term1, term2, term3)\n\n small = term2\n if term1 > small\n small = term1\n end\n \n if small < term3\n small = term3\n end\n return small\nend",
"def my_min2(int_list)\n min = 0\n\n int_list.each do |int|\n min = int if int < min\n end\n\n min\nend"
] |
[
"0.8710521",
"0.8630299",
"0.8625952",
"0.8618415",
"0.8486882",
"0.84854436",
"0.84593624",
"0.8367043",
"0.8249906",
"0.8190739",
"0.81882954",
"0.7978395",
"0.78643876",
"0.77731806",
"0.7709521",
"0.7591844",
"0.7572726",
"0.7541311",
"0.7486121",
"0.7462298",
"0.74243444",
"0.7404006",
"0.7398118",
"0.7330153",
"0.7286296",
"0.7254584",
"0.72413975",
"0.719024",
"0.7174703",
"0.71078086",
"0.71008843",
"0.7044523",
"0.70067614",
"0.70067614",
"0.69767785",
"0.6916821",
"0.69160193",
"0.68760276",
"0.6866775",
"0.6834208",
"0.67965233",
"0.6774549",
"0.676811",
"0.67652845",
"0.67323613",
"0.67306715",
"0.67276645",
"0.66929156",
"0.667365",
"0.66652817",
"0.6649585",
"0.6641381",
"0.66400737",
"0.6621114",
"0.6588308",
"0.6577743",
"0.6577661",
"0.6566729",
"0.65659356",
"0.6562719",
"0.6562446",
"0.65468",
"0.6544072",
"0.65119547",
"0.6511271",
"0.6492016",
"0.64698046",
"0.64598763",
"0.6433961",
"0.64301515",
"0.64229745",
"0.641747",
"0.64011776",
"0.63941157",
"0.63935566",
"0.6387963",
"0.638534",
"0.6378465",
"0.6378022",
"0.63750297",
"0.637156",
"0.63702023",
"0.63686925",
"0.63685966",
"0.63657767",
"0.63508755",
"0.6341761",
"0.6337053",
"0.6325889",
"0.6315066",
"0.6313713",
"0.63024056",
"0.6282869",
"0.62798685",
"0.6240502",
"0.6240125",
"0.6235904",
"0.62089396",
"0.62066054",
"0.6181577"
] |
0.85761714
|
4
|
Show invalid properties with the reasons. Usually used together with valid?
|
def list_invalid_properties
invalid_properties = Array.new
if @id.nil?
invalid_properties.push('invalid value for "id", id cannot be nil.')
end
if @title.nil?
invalid_properties.push('invalid value for "title", title cannot be nil.')
end
if @title.to_s.length < 1
invalid_properties.push('invalid value for "title", the character length must be great than or equal to 1.')
end
if @image.nil?
invalid_properties.push('invalid value for "image", image cannot be nil.')
end
if @image.to_s.length < 1
invalid_properties.push('invalid value for "image", the character length must be great than or equal to 1.')
end
if @image_type.nil?
invalid_properties.push('invalid value for "image_type", image_type cannot be nil.')
end
if @image_type.to_s.length < 1
invalid_properties.push('invalid value for "image_type", the character length must be great than or equal to 1.')
end
if @servings.nil?
invalid_properties.push('invalid value for "servings", servings cannot be nil.')
end
if @ready_in_minutes.nil?
invalid_properties.push('invalid value for "ready_in_minutes", ready_in_minutes cannot be nil.')
end
if @license.nil?
invalid_properties.push('invalid value for "license", license cannot be nil.')
end
if @license.to_s.length < 1
invalid_properties.push('invalid value for "license", the character length must be great than or equal to 1.')
end
if @source_name.nil?
invalid_properties.push('invalid value for "source_name", source_name cannot be nil.')
end
if @source_name.to_s.length < 1
invalid_properties.push('invalid value for "source_name", the character length must be great than or equal to 1.')
end
if @source_url.nil?
invalid_properties.push('invalid value for "source_url", source_url cannot be nil.')
end
if @source_url.to_s.length < 1
invalid_properties.push('invalid value for "source_url", the character length must be great than or equal to 1.')
end
if @spoonacular_source_url.nil?
invalid_properties.push('invalid value for "spoonacular_source_url", spoonacular_source_url cannot be nil.')
end
if @spoonacular_source_url.to_s.length < 1
invalid_properties.push('invalid value for "spoonacular_source_url", the character length must be great than or equal to 1.')
end
if @aggregate_likes.nil?
invalid_properties.push('invalid value for "aggregate_likes", aggregate_likes cannot be nil.')
end
if @health_score.nil?
invalid_properties.push('invalid value for "health_score", health_score cannot be nil.')
end
if @spoonacular_score.nil?
invalid_properties.push('invalid value for "spoonacular_score", spoonacular_score cannot be nil.')
end
if @price_per_serving.nil?
invalid_properties.push('invalid value for "price_per_serving", price_per_serving cannot be nil.')
end
if @cheap.nil?
invalid_properties.push('invalid value for "cheap", cheap cannot be nil.')
end
if @credits_text.nil?
invalid_properties.push('invalid value for "credits_text", credits_text cannot be nil.')
end
if @credits_text.to_s.length < 1
invalid_properties.push('invalid value for "credits_text", the character length must be great than or equal to 1.')
end
if @dairy_free.nil?
invalid_properties.push('invalid value for "dairy_free", dairy_free cannot be nil.')
end
if @gaps.nil?
invalid_properties.push('invalid value for "gaps", gaps cannot be nil.')
end
if @gaps.to_s.length < 1
invalid_properties.push('invalid value for "gaps", the character length must be great than or equal to 1.')
end
if @gluten_free.nil?
invalid_properties.push('invalid value for "gluten_free", gluten_free cannot be nil.')
end
if @instructions.nil?
invalid_properties.push('invalid value for "instructions", instructions cannot be nil.')
end
if @ketogenic.nil?
invalid_properties.push('invalid value for "ketogenic", ketogenic cannot be nil.')
end
if @low_fodmap.nil?
invalid_properties.push('invalid value for "low_fodmap", low_fodmap cannot be nil.')
end
if @sustainable.nil?
invalid_properties.push('invalid value for "sustainable", sustainable cannot be nil.')
end
if @vegan.nil?
invalid_properties.push('invalid value for "vegan", vegan cannot be nil.')
end
if @vegetarian.nil?
invalid_properties.push('invalid value for "vegetarian", vegetarian cannot be nil.')
end
if @very_healthy.nil?
invalid_properties.push('invalid value for "very_healthy", very_healthy cannot be nil.')
end
if @very_popular.nil?
invalid_properties.push('invalid value for "very_popular", very_popular cannot be nil.')
end
if @whole30.nil?
invalid_properties.push('invalid value for "whole30", whole30 cannot be nil.')
end
if @weight_watcher_smart_points.nil?
invalid_properties.push('invalid value for "weight_watcher_smart_points", weight_watcher_smart_points cannot be nil.')
end
if !@extended_ingredients.nil? && @extended_ingredients.length < 0
invalid_properties.push('invalid value for "extended_ingredients", number of items must be greater than or equal to 0.')
end
if @summary.nil?
invalid_properties.push('invalid value for "summary", summary cannot be nil.')
end
if @summary.to_s.length < 1
invalid_properties.push('invalid value for "summary", the character length must be great than or equal to 1.')
end
invalid_properties
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n pattern = Regexp.new(/^$|^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)\n if !@uuid.nil? && @uuid !~ pattern\n invalid_properties.push(\"invalid value for \\\"uuid\\\", must conform to the pattern #{pattern}.\")\n end\n\n pattern = Regexp.new(/^$|^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)\n if !@vdisk_id.nil? && @vdisk_id !~ pattern\n invalid_properties.push(\"invalid value for \\\"vdisk_id\\\", must conform to the pattern #{pattern}.\")\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @style.nil?\n invalid_properties.push('invalid value for \"style\", style cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n if !@name.nil? && @name.to_s.length > 31\n invalid_properties.push('invalid value for \"name\", the character length must be smaller than or equal to 31.')\n end\n\n pattern = Regexp.new(/^[a-zA-Z0-9\\-\\._:]+$/)\n if !@name.nil? && @name !~ pattern\n invalid_properties.push(\"invalid value for \\\"name\\\", must conform to the pattern #{pattern}.\")\n end\n\n pattern = Regexp.new(/^$|((^20|5[0-9a-fA-F]{1}):([0-9a-fA-F]{2}:){6}([0-9a-fA-F]{2}))/)\n if !@static_wwpn_address.nil? && @static_wwpn_address !~ pattern\n invalid_properties.push(\"invalid value for \\\"static_wwpn_address\\\", must conform to the pattern #{pattern}.\")\n end\n\n pattern = Regexp.new(/^$|((^20|5[0-9a-fA-F]{1}):([0-9a-fA-F]{2}:){6}([0-9a-fA-F]{2}))/)\n if !@wwpn.nil? && @wwpn !~ pattern\n invalid_properties.push(\"invalid value for \\\"wwpn\\\", must conform to the pattern #{pattern}.\")\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @is_object_icon.nil?\n invalid_properties.push('invalid value for \"is_object_icon\", is_object_icon cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n if @input_currency.nil?\n invalid_properties.push('invalid value for \"input_currency\", input_currency cannot be nil.')\n end\n\n if @sender.nil?\n invalid_properties.push('invalid value for \"sender\", sender cannot be nil.')\n end\n\n if @recipients.nil?\n invalid_properties.push('invalid value for \"recipients\", recipients cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @index.nil?\n invalid_properties.push('invalid value for \"index\", index cannot be nil.')\n end\n\n if @orientation.nil?\n invalid_properties.push('invalid value for \"orientation\", orientation cannot be nil.')\n end\n\n if @size.nil?\n invalid_properties.push('invalid value for \"size\", size cannot be nil.')\n end\n\n if @type.nil?\n invalid_properties.push('invalid value for \"type\", type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @direction.nil?\n invalid_properties.push('invalid value for \"direction\", direction cannot be nil.')\n end\n\n if @shape.nil?\n invalid_properties.push('invalid value for \"shape\", shape cannot be nil.')\n end\n\n if @linear_angle.nil?\n invalid_properties.push('invalid value for \"linear_angle\", linear_angle cannot be nil.')\n end\n\n if @is_scaled.nil?\n invalid_properties.push('invalid value for \"is_scaled\", is_scaled cannot be nil.')\n end\n\n if @tile_flip.nil?\n invalid_properties.push('invalid value for \"tile_flip\", tile_flip cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n if @format.nil?\n invalid_properties.push('invalid value for \"format\", format cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = Array.new\n invalid_properties\n end"
] |
[
"0.76497203",
"0.76497203",
"0.76497203",
"0.76497203",
"0.7637422",
"0.7637422",
"0.7637422",
"0.7637422",
"0.7637422",
"0.7637422",
"0.7637422",
"0.7637422",
"0.7356452",
"0.7334807",
"0.72685325",
"0.7238964",
"0.7231359",
"0.72258264",
"0.7208294",
"0.71760833",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241",
"0.7170241"
] |
0.0
|
-1
|
Check to see if the all the properties in the model are valid
|
def valid?
return false if @id.nil?
return false if @title.nil?
return false if @title.to_s.length < 1
return false if @image.nil?
return false if @image.to_s.length < 1
return false if @image_type.nil?
return false if @image_type.to_s.length < 1
return false if @servings.nil?
return false if @ready_in_minutes.nil?
return false if @license.nil?
return false if @license.to_s.length < 1
return false if @source_name.nil?
return false if @source_name.to_s.length < 1
return false if @source_url.nil?
return false if @source_url.to_s.length < 1
return false if @spoonacular_source_url.nil?
return false if @spoonacular_source_url.to_s.length < 1
return false if @aggregate_likes.nil?
return false if @health_score.nil?
return false if @spoonacular_score.nil?
return false if @price_per_serving.nil?
return false if @cheap.nil?
return false if @credits_text.nil?
return false if @credits_text.to_s.length < 1
return false if @dairy_free.nil?
return false if @gaps.nil?
return false if @gaps.to_s.length < 1
return false if @gluten_free.nil?
return false if @instructions.nil?
return false if @ketogenic.nil?
return false if @low_fodmap.nil?
return false if @sustainable.nil?
return false if @vegan.nil?
return false if @vegetarian.nil?
return false if @very_healthy.nil?
return false if @very_popular.nil?
return false if @whole30.nil?
return false if @weight_watcher_smart_points.nil?
return false if !@extended_ingredients.nil? && @extended_ingredients.length < 0
return false if @summary.nil?
return false if @summary.to_s.length < 1
true
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def validate_properties\n true\n end",
"def validate_properties\n true\n end",
"def validate\n super\n\n check_optional_property :collection, String\n check_optional_property :create, String\n check_optional_property :delete, String\n check_optional_property :flush, String\n check_optional_property :prefetch, String\n check_optional_property :request_to_query, String\n check_optional_property :resource_to_request_patch, String\n check_optional_property :return_if_object, String\n check_optional_property :self_link, String\n end",
"def valid_attributes?\n true\n end",
"def valid_attributes?\n attribute_errors.empty?\n end",
"def valid?\n return false if @property_code.nil?\n return false if @property_name.nil?\n return false if @location.nil?\n return false if @total_price.nil?\n return false if @min_daily_rate.nil?\n return true\n end",
"def validate_presence_of(klazz, properties)\r\n instance = klazz.new \r\n instance.should_not be_valid\r\n \r\n properties.each do |property| \r\n instance.errors.should be_invalid(property)\r\n err_properties = instance.errors[property]\r\n if err_properties.is_a? Array\r\n err_properties.include?(ActiveRecord::Errors.default_error_messages[:blank]).should be_true\r\n else\r\n err_properties.should == ActiveRecord::Errors.default_error_messages[:blank] \r\n end\r\n end \r\n end",
"def validate_attributes!(attributes)\n invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys\n raise UndefinedPropertyError, \"Undefined properties: #{invalid_properties.join(',')}\" if invalid_properties.size > 0\n end",
"def model_valid?\n true\n end",
"def model_valid?\n true\n end",
"def valid?\n self.errors = []\n self.content_type.fields.each do |field|\n if field.required\n if self.dynamic_getter(field.name).blank?\n self.errors << field.name\n end\n end\n end\n self.errors.blank?\n end",
"def valid?\n validate\n @model.errors.on(:preferences).blank?\n end",
"def validate_properties\n if @properties.keys.count > 0\n if @properties.key?(:label)\n unless @properties[:label] =~ /^[a-zA-Z][\\w|\\s]*$/\n raise 'property label validation error'\n end\n end\n\n if @properties.key?(:default_aggregate)\n unless @properties[:default_aggregate] =~ /^max$|^min$|^avg$|^count$/i\n raise 'property default_aggregate validation error'\n end\n end\n end\n end",
"def validate_properties\n @properties.each do |property, values|\n valid_values = validate_values(property, values)\n\n if valid_values.is_a?(Array) && valid_values == [] || valid_values.nil?\n @properties.delete(property)\n else\n @properties[property] = valid_values\n end\n end\n end",
"def validate\n valid?\n end",
"def validate_attributes!(attributes)\n return attributes if attributes.blank?\n invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys\n invalid_properties.reject! { |name| self.respond_to?(\"#{name}=\") }\n fail UndefinedPropertyError, \"Undefined properties: #{invalid_properties.join(',')}\" if !invalid_properties.empty?\n end",
"def is_valid; end",
"def valid?\n # TODO validate nested objects\n output = super\n errors.empty? && output\n end",
"def property_checks\n errors.add(:base, \"You can't have a Thing without properties\") if property_keys.empty?\n\n self.property_keys.each do |key|\n errors.add(:properties, \"'#{key}' is an invalid property for this List\") unless available_property_keys.include?(key)\n end\n end",
"def valid_for_attributes( model, attributes )\n unless model.valid?\n errors = model.errors\n our_errors = Array.new\n errors.each { |attr,error|\n if attributes.include? attr\n our_errors << [attr,error]\n end\n }\n errors.clear\n our_errors.each { |attr,error| errors.add(attr,error) }\n return false unless errors.empty?\n end\n return true\n end",
"def valid?\n type_validator = EnumAttributeValidator.new('String', [\"person\", \"business\"])\n return false unless type_validator.valid?(@type)\n return false if @country.nil?\n return false if @street.nil?\n return false if @postal_code.nil?\n return false if @city.nil?\n return false if @email.nil?\n return false if @ip.nil?\n identification_type_validator = EnumAttributeValidator.new('String', [\"DL\", \"PP\", \"ID\", \"OT\"])\n return false unless identification_type_validator.valid?(@identification_type)\n legal_entity_type_validator = EnumAttributeValidator.new('String', [\"sole_proprietorship\", \"partnership\", \"privately_owned_company\", \"publicly_owned_company\", \"government_owned_entity\", \"trust\", \"ngo\", \"club_and_society\", \"go\", \"other\", \"financial_institution\", \"mto\"])\n return false unless legal_entity_type_validator.valid?(@legal_entity_type)\n nature_of_business_validator = EnumAttributeValidator.new('String', [\"personal\", \"agriculture_and_hunting\", \"forestry\", \"fishing\", \"agricultural_by_products\", \"coal_mining\", \"oil_mining\", \"iron_ore_mining\", \"other_metal_and_diamond_mining\", \"other_mineral_mining\", \"manufacturing_of_food_drink_tobacco\", \"manufacturing_of_textiles_leather_fur_furniture\", \"manufacture_of_wooden_products_furniture\", \"manufacture_of_paper_pulp_allied_products\", \"manufacture_of_chemicals_medical_petroleum_rubber_plastic_products\", \"manufacture_of_pottery_china_glass_stone\", \"manufacture_of_iron_steel_non_ferrous_metals_basic_industries\", \"manufacture_of_metal_products_electrical_and_scientific_engineering\", \"manufacture_of_jewelry_musical_instruments_toys\", \"electricity_gas_and_water\", \"construction\", \"wholesale_trade\", \"retail_trade\", \"catering_incl_hotels\", \"transport_storage\", \"communications\", \"finance_and_holding_companies\", \"insurance\", \"business_services\", \"real_estate_development_investment\", \"central_state_governments\", \"community_services_defence_police_prisons_etc\", \"social_services_education_health_care\", \"personal_services_leisure_services\", \"personal_services_domestic_laundry_repairs\", \"personal_services_embassies_international_organisations\"])\n return false unless nature_of_business_validator.valid?(@nature_of_business)\n return false if @documents.nil?\n gender_validator = EnumAttributeValidator.new('String', [\"M\", \"F\", \"O\"])\n return false unless gender_validator.valid?(@gender)\n true\n end",
"def valid?\n return false if !super\n return false if @index.nil?\n return false if @orientation.nil?\n orientation_validator = EnumAttributeValidator.new('String', ['Horizontal', 'Vertical'])\n return false unless orientation_validator.valid?(@orientation)\n return false if @size.nil?\n size_validator = EnumAttributeValidator.new('String', ['Full', 'Half', 'Quarter'])\n return false unless size_validator.valid?(@size)\n return false if @type.nil?\n type_validator = EnumAttributeValidator.new('String', ['Title', 'Body', 'CenteredTitle', 'Subtitle', 'DateAndTime', 'SlideNumber', 'Footer', 'Header', 'Object', 'Chart', 'Table', 'ClipArt', 'Diagram', 'Media', 'SlideImage', 'Picture'])\n return false unless type_validator.valid?(@type)\n true\n end",
"def validate\n validate_string_attributes\n @relations.map(&:validate)\n end",
"def is_valid?\n end",
"def run_validations\n true\n end",
"def validate\n validate_params\n validate_colour\n validate_coordinates\n validate_dimension\n end",
"def checkAttributeRequirements\n if @valid_attributes.empty?\n @error_text = \"No valid attributes found\"\n return false\n elsif (@mandatory_attributes_from_db & @valid_attributes) != @mandatory_attributes_from_db\n missing_attr = @mandatory_attributes_from_db - (@mandatory_attributes_from_db & @valid_attributes)\n\n x_attr_txt = \"\"\n missing_attr.each {|x_attr| x_attr_txt += x_attr[:name] + \", \"}\n @error_text = \"Mandatory attributes #{x_attr_txt[0..-3]} is/are missing\"\n return false\n end\n\n return true\n end",
"def validations\n {}\n end",
"def validatable?\n true\n end",
"def validate\n validate_params\n validate_coordinates\n validate_colour\n validate_dimension\n end",
"def validate_required\n [\n :project_name,\n :status,\n :requester_id,\n :subject_expert_id,\n :sponsor_id,\n :vision,\n :goal,\n :description,\n :scope,\n :advice_required,\n :program_id,\n :train_id,\n :funding_method,\n :cost_center,\n :funding_status,\n :budget_allocated,\n :priority,\n :start_date,\n :end_date,\n :risk_rating,\n :risks,\n :projected_revenue,\n ].each do |field|\n if self.attributes[field.to_s].nil? || self.attributes[field.to_s].blank?\n # intentionally vague!\n add_validation 'All fields are required to perform further validations'\n return false\n end\n end\n true\n end",
"def validate\n validate_root\n validate_associated\n valid?\n end",
"def validate\n true\n end",
"def valid?\n return false if @id.nil?\n return false if @created.nil?\n return false if @modified.nil?\n return false if @company_name.nil?\n return false if @company_name.to_s.length < 1\n return false if @domain_name.nil?\n return false if @state.nil?\n state_validator = EnumAttributeValidator.new('String', [\"active\", \"deactivated\"])\n return false unless state_validator.valid?(@state)\n return false if @billing_email.nil?\n return false if @application_count.nil?\n return false if @user_count.nil?\n return false if @campaigns_active_count.nil?\n return false if @campaigns_inactive_count.nil?\n true\n end",
"def valid?\n _errors_before = self.errors.dup\n _s = super\n validate_attributes\n _errors_before.each { |e| append_error(_errors_before,e) }\n self.errors.empty?\n end",
"def valid?\n true\n end",
"def validate!\n expected_props, required_props = @properties.keys, @required\n\n unless is_a?(Dialect) || is_a?(Template)\n expected_props = expected_props + INHERITED_PROPERTIES.keys\n end\n\n # It has only expected properties (exclude metadata)\n keys = self.keys - [:\"@context\"]\n keys = keys.reject {|k| k.to_s.include?(':')} unless is_a?(Dialect)\n raise \"#{type} has unexpected keys: #{keys - expected_props}\" unless keys.all? {|k| expected_props.include?(k)}\n\n # It has required properties\n raise \"#{type} missing required keys: #{required_props & keys}\" unless (required_props & keys) == required_props\n\n # Every property is valid\n keys.each do |key|\n value = self[key]\n is_valid = case key\n when :columns\n column_names = value.map(&:name)\n value.is_a?(Array) &&\n value.all? {|v| v.is_a?(Column) && v.validate!} &&\n begin\n # The name properties of the column descriptions must be unique within a given table description.\n column_names = value.map(&:name)\n raise \"Columns must have unique names\" if column_names.uniq != column_names\n true\n end\n when :commentPrefix then value.is_a?(String) && value.length == 1\n when :datatype then value.is_a?(String) && DATATYPES.keys.map(&:to_s).include?(value)\n when :default then value.is_a?(String)\n when :delimiter then value.is_a?(String) && value.length == 1\n when :dialect then value.is_a?(Dialect) && value.validate!\n when :doubleQuote then %w(true false 1 0).include?(value.to_s.downcase)\n when :encoding then Encoding.find(value)\n when :foreignKeys\n # An array of foreign key definitions that define how the values from specified columns within this table link to rows within this table or other tables. A foreign key definition is a JSON object with the properties:\n value.is_a?(Array) && value.all? do |fk|\n raise \"Foreign key must be an object\" unless fk.is_a?(Hash)\n columns, reference = fk['columns'], fk['reference']\n raise \"Foreign key missing columns and reference\" unless columns && reference\n raise \"Foreign key has extra entries\" unless fk.keys.length == 2\n raise \"Foreign key must reference columns\" unless Array(columns).all? {|k| self.columns.any? {|c| c.name == k}}\n raise \"Foreign key reference must be an Object\" unless reference.is_a?(Hash)\n\n if reference.has_key?('resource')\n raise \"Foreign key having a resource reference, must not have a schema\" if reference.has_key?('schema')\n # FIXME resource is a URL of a specific resource (table) which must exist\n elsif reference.has_key?('schema')\n # FIXME schema is a URL of a specific schema which must exist\n end\n # FIXME: columns\n true\n end\n when :format then value.is_a?(String)\n when :header then %w(true false 1 0).include?(value.to_s.downcase)\n when :headerColumnCount, :headerRowCount\n value.is_a?(Numeric) && value.integer? && value > 0\n when :length\n # Applications must raise an error if length, maxLength or minLength are specified and the cell value is not a list (ie separator is not specified), a string or one of its subtypes, or a binary value.\n raise \"Use if minLength or maxLength with length requires separator\" if self[:minLength] || self[:maxLength] && !self[:separator]\n raise \"Use of both length and minLength requires they be equal\" unless self.fetch(:minLength, value) == value\n raise \"Use of both length and maxLength requires they be equal\" unless self.fetch(:maxLength, value) == value\n value.is_a?(Numeric) && value.integer? && value > 0\n when :language then BCP47::Language.identify(value)\n when :lineTerminator then value.is_a?(String)\n when :minimum, :maximum, :minInclusive, :maxInclusive, :minExclusive, :maxExclusive\n value.is_a?(Numeric) ||\n RDF::Literal::Date.new(value).valid? ||\n RDF::Literal::Time.new(value).valid? ||\n RDF::Literal::DateTime.new(value).valid?\n when :minLength, :maxLength\n value.is_a?(Numeric) && value.integer? && value > 0\n when :name then value.is_a?(String) && !name.start_with?(\"_\")\n when :notes then value.is_a?(Array) && value.all? {|v| v.is_a?(Hash)}\n when :null then value.is_a?(String)\n when :predicateUrl then Array(value).all? {|v| RDF::URI(v).valid?}\n when :primaryKey\n # A column reference property that holds either a single reference to a column description object or an array of references.\n Array(value).all? do |k|\n self.columns.any? {|c| c.name == k}\n end\n when :quoteChar then value.is_a?(String) && value.length == 1\n when :required then %w(true false 1 0).include?(value.to_s.downcase)\n when :resources then value.is_a?(Array) && value.all? {|v| v.is_a?(Table) && v.validate!}\n when :schema then value.is_a?(Schema) && value.validate!\n when :separator then value.nil? || value.is_a?(String) && value.length == 1\n when :skipInitialSpace then %w(true false 1 0).include?(value.to_s.downcase)\n when :skipBlankRows then %w(true false 1 0).include?(value.to_s.downcase)\n when :skipColumns then value.is_a?(Numeric) && value.integer? && value >= 0\n when :skipRows then value.is_a?(Numeric) && value.integer? && value >= 0\n when :source then %w(json rdf).include?(value)\n when :\"table-direction\" then %w(rtl ltr default).include?(value)\n when :targetFormat, :templateFormat then RDF::URI(value).valid?\n when :templates then value.is_a?(Array) && value.all? {|v| v.is_a?(Template) && v.validate!}\n when :\"text-direction\" then %w(rtl ltr).include?(value)\n when :title then valid_natural_language_property?(value)\n when :trim then %w(true false 1 0 start end).include?(value.to_s.downcase)\n when :urlTemplate then value.is_a?(String)\n when :@id then @id.valid?\n when :@type then value.to_sym == type\n else\n raise \"?!?! shouldn't get here for key #{key}\"\n end\n raise \"#{type} has invalid #{key}: #{value.inspect}\" unless is_valid\n end\n\n self\n end",
"def valid?\n return false if @subject_property.nil?\n return false if @proprietorship.nil?\n proprietorship_validator = EnumAttributeValidator.new('String', [\"Unknown\", \"Sole\", \"Joint\"])\n return false unless proprietorship_validator.valid?(@proprietorship)\n return false if @surname.nil?\n return false if @forename.nil?\n return false if @middle_name.nil?\n return true\n end",
"def valid?\n return false if @class_id.nil?\n class_id_validator = EnumAttributeValidator.new('String', [\"cond.HclStatusDetail\"])\n return false unless class_id_validator.valid?(@class_id)\n return false if @object_type.nil?\n object_type_validator = EnumAttributeValidator.new('String', [\"cond.HclStatusDetail\"])\n return false unless object_type_validator.valid?(@object_type)\n hardware_status_validator = EnumAttributeValidator.new('String', [\"Missing-Os-Driver-Info\", \"Incompatible-Server-With-Component\", \"Incompatible-Processor\", \"Incompatible-Os-Info\", \"Incompatible-Component-Model\", \"Incompatible-Firmware\", \"Incompatible-Driver\", \"Incompatible-Firmware-Driver\", \"Service-Unavailable\", \"Service-Error\", \"Unrecognized-Protocol\", \"Not-Evaluated\", \"Compatible\"])\n return false unless hardware_status_validator.valid?(@hardware_status)\n reason_validator = EnumAttributeValidator.new('String', [\"Missing-Os-Driver-Info\", \"Incompatible-Server-With-Component\", \"Incompatible-Processor\", \"Incompatible-Os-Info\", \"Incompatible-Component-Model\", \"Incompatible-Firmware\", \"Incompatible-Driver\", \"Incompatible-Firmware-Driver\", \"Service-Unavailable\", \"Service-Error\", \"Unrecognized-Protocol\", \"Not-Evaluated\", \"Compatible\"])\n return false unless reason_validator.valid?(@reason)\n software_status_validator = EnumAttributeValidator.new('String', [\"Missing-Os-Driver-Info\", \"Incompatible-Server-With-Component\", \"Incompatible-Processor\", \"Incompatible-Os-Info\", \"Incompatible-Component-Model\", \"Incompatible-Firmware\", \"Incompatible-Driver\", \"Incompatible-Firmware-Driver\", \"Service-Unavailable\", \"Service-Error\", \"Unrecognized-Protocol\", \"Not-Evaluated\", \"Compatible\"])\n return false unless software_status_validator.valid?(@software_status)\n status_validator = EnumAttributeValidator.new('String', [\"Incomplete\", \"Not-Found\", \"Not-Listed\", \"Validated\", \"Not-Evaluated\"])\n return false unless status_validator.valid?(@status)\n true && super\n end",
"def core_attributes_valid\n core_attributes = [@rateable, @rater, @ratee, @rating_type]\n return if core_attributes.all? { |atr| atr.present? && atr.valid? }\n errors.add('message', 'Not all core attributes present and valid.')\n end",
"def valid?\n super\n errors.empty?\n end",
"def valid?\n \n if @account_id.nil?\n false\n elsif @campaign_id.nil?\n false\n elsif @csp_id.nil?\n false\n elsif @status.nil?\n false\n elsif @create_date.nil?\n false\n elsif @auto_renewal.nil?\n false\n elsif @brand_id.nil?\n false\n elsif @usecase.nil?\n false\n elsif @sub_usecases.nil?\n false\n elsif @description.nil?\n false\n elsif @embedded_link.nil?\n false\n elsif @embedded_phone.nil?\n false\n elsif @affiliate_marketing.nil?\n false\n elsif @number_pool.nil?\n false\n elsif @age_gated.nil?\n false\n elsif @direct_lending.nil?\n false\n elsif @subscriber_optin.nil?\n false\n elsif @subscriber_optout.nil?\n false\n elsif @subscriber_help.nil?\n false\n elsif @sample1.nil?\n false\n elsif @mock.nil?\n false\n else\n list_invalid_properties.length() == 0\n end\n end",
"def valid?(metadata)\n validate.each do |attr|\n return false if metadata[attr.to_sym].nil? || metadata[attr.to_sym].zero?\n end\n end",
"def is_valid\n return true\n end",
"def validate_attrs\n @target.present? && !@target.errors.any? && @actor.present? && @action_key.present?\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n if !@name.nil? && @name.to_s.length > 31\n invalid_properties.push('invalid value for \"name\", the character length must be smaller than or equal to 31.')\n end\n\n pattern = Regexp.new(/^[a-zA-Z0-9\\-\\._:]+$/)\n if !@name.nil? && @name !~ pattern\n invalid_properties.push(\"invalid value for \\\"name\\\", must conform to the pattern #{pattern}.\")\n end\n\n pattern = Regexp.new(/^$|((^20|5[0-9a-fA-F]{1}):([0-9a-fA-F]{2}:){6}([0-9a-fA-F]{2}))/)\n if !@static_wwpn_address.nil? && @static_wwpn_address !~ pattern\n invalid_properties.push(\"invalid value for \\\"static_wwpn_address\\\", must conform to the pattern #{pattern}.\")\n end\n\n pattern = Regexp.new(/^$|((^20|5[0-9a-fA-F]{1}):([0-9a-fA-F]{2}:){6}([0-9a-fA-F]{2}))/)\n if !@wwpn.nil? && @wwpn !~ pattern\n invalid_properties.push(\"invalid value for \\\"wwpn\\\", must conform to the pattern #{pattern}.\")\n end\n\n invalid_properties\n end",
"def valid_save?\n valid = true\n\n if self.name.nil? || self.name == \"\"\n valid = false\n end\n\n if self.general_info.nil? || self.general_info == \"\"\n valid = false\n end\n\n if self.technical_specs.nil? || self.technical_specs == \"\"\n valid = false\n end\n\n if self.where_to_buy.nil? || self.where_to_buy == \"\"\n valid = false\n end\n\n return valid\n end",
"def valid?\n schema.validate(self)\n end",
"def valid?\n reset_errors\n valid_date?\n valid_user?\n valid_activity_type?\n self.errors.empty?\n end",
"def valid?\n validate\n end",
"def product_attributes_must_not_be_empty\n\n\t\t# Instance\n\t\tproduct = Product.new\n\n\t\tassert product.invalid?\n\t\tassert product.errors[:title].any?\n\t\tassert product.errors[:description].any?\n\t\tassert product.errors[:price].any?\n\t\tassert product.errors[:image_url].any?\n\tend",
"def valid?\n return false if @id.nil?\n return false if @id !~ Regexp.new(/^psc_[a-zA-Z0-9]+$/)\n carrier_validator = EnumAttributeValidator.new('String', [\"USPS\"])\n return false unless carrier_validator.valid?(@carrier)\n return false if !@front_template_id.nil? && @front_template_id !~ Regexp.new(/^tmpl_[a-zA-Z0-9]+$/)\n return false if !@back_template_id.nil? && @back_template_id !~ Regexp.new(/^tmpl_[a-zA-Z0-9]+$/)\n return false if !@front_template_version_id.nil? && @front_template_version_id !~ Regexp.new(/^vrsn_[a-zA-Z0-9]+$/)\n return false if !@back_template_version_id.nil? && @back_template_version_id !~ Regexp.new(/^vrsn_[a-zA-Z0-9]+$/)\n object_validator = EnumAttributeValidator.new('String', [\"postcard\"])\n return false unless object_validator.valid?(@object)\n return false if @url.nil?\n return false if @url !~ Regexp.new(/^https:\\/\\/(lob-assets|lob-assets-staging)\\.com\\/(letters|postcards|bank-accounts|checks|self-mailers|cards)\\/[a-z]{3,4}_[a-z0-9]{15,16}(\\.pdf|_thumb_[a-z]+_[0-9]+\\.png)\\?(version=[a-z0-9-]*&)?expires=[0-9]{10}&signature=[a-zA-Z0-9_-]+$/)\n return false if !@description.nil? && @description.to_s.length > 255\n true\n end",
"def valid?\n return false if @class_id.nil?\n class_id_validator = EnumAttributeValidator.new('String', [\"network.ElementSummary\"])\n return false unless class_id_validator.valid?(@class_id)\n return false if @object_type.nil?\n object_type_validator = EnumAttributeValidator.new('String', [\"network.ElementSummary\"])\n return false unless object_type_validator.valid?(@object_type)\n ethernet_switching_mode_validator = EnumAttributeValidator.new('String', [\"end-host\", \"switch\"])\n return false unless ethernet_switching_mode_validator.valid?(@ethernet_switching_mode)\n fc_switching_mode_validator = EnumAttributeValidator.new('String', [\"end-host\", \"switch\"])\n return false unless fc_switching_mode_validator.valid?(@fc_switching_mode)\n management_mode_validator = EnumAttributeValidator.new('String', [\"IntersightStandalone\", \"UCSM\", \"Intersight\"])\n return false unless management_mode_validator.valid?(@management_mode)\n thermal_validator = EnumAttributeValidator.new('String', [\"unknown\", \"ok\", \"upper-non-recoverable\", \"upper-critical\", \"upper-non-critical\", \"lower-non-critical\", \"lower-critical\", \"lower-non-recoverable\"])\n return false unless thermal_validator.valid?(@thermal)\n true && super\n end",
"def valid?\n\t\t\t\ttrue\n\t\t\tend",
"def validate\r\n validate! rescue false\r\n end",
"def validate\n validate_string_attributes\n end",
"def valid?\n self.errors = Mongomatic::Errors.new\n do_callback(:before_validate)\n check_required_fields\n validate\n do_callback(:after_validate)\n self.errors.empty?\n end",
"def valid\n @valid\n end",
"def valid_objects\n all_objects.select { |o| o.valid? }\n end",
"def valid?\n return false if @summary.nil?\n return false if @summary.to_s.length > 100\n record_type_validator = EnumAttributeValidator.new('String', [\"ServiceTicket\", \"ProjectTicket\", \"ProjectIssue\"])\n return false unless record_type_validator.valid?(@record_type)\n return false if !@wbs_code.nil? && @wbs_code.to_s.length > 50\n return false if @company.nil?\n return false if !@site_name.nil? && @site_name.to_s.length > 50\n return false if !@address_line1.nil? && @address_line1.to_s.length > 50\n return false if !@address_line2.nil? && @address_line2.to_s.length > 50\n return false if !@city.nil? && @city.to_s.length > 50\n return false if !@state_identifier.nil? && @state_identifier.to_s.length > 50\n return false if !@zip.nil? && @zip.to_s.length > 12\n return false if !@contact_phone_number.nil? && @contact_phone_number.to_s.length > 20\n return false if !@contact_phone_extension.nil? && @contact_phone_extension.to_s.length > 15\n return false if !@contact_email_address.nil? && @contact_email_address.to_s.length > 250\n severity_validator = EnumAttributeValidator.new('String', [\"Low\", \"Medium\", \"High\"])\n return false unless severity_validator.valid?(@severity)\n impact_validator = EnumAttributeValidator.new('String', [\"Low\", \"Medium\", \"High\"])\n return false unless impact_validator.valid?(@impact)\n return false if !@external_x_ref.nil? && @external_x_ref.to_s.length > 100\n return false if !@po_number.nil? && @po_number.to_s.length > 50\n return false if !@automatic_email_cc.nil? && @automatic_email_cc.to_s.length > 1000\n sub_billing_method_validator = EnumAttributeValidator.new('String', [\"ActualRates\", \"FixedFee\", \"NotToExceed\", \"OverrideRate\"])\n return false unless sub_billing_method_validator.valid?(@sub_billing_method)\n knowledge_base_link_type_validator = EnumAttributeValidator.new('String', [\"ServiceTicket\", \"ProjectTicket\", \"ProjectIssue\", \"KnowledgeBaseArticle\", \"Time\", \"Activity\"])\n return false unless knowledge_base_link_type_validator.valid?(@knowledge_base_link_type)\n bill_time_validator = EnumAttributeValidator.new('String', [\"Billable\", \"DoNotBill\", \"NoCharge\", \"NoDefault\"])\n return false unless bill_time_validator.valid?(@bill_time)\n bill_expenses_validator = EnumAttributeValidator.new('String', [\"Billable\", \"DoNotBill\", \"NoCharge\", \"NoDefault\"])\n return false unless bill_expenses_validator.valid?(@bill_expenses)\n bill_products_validator = EnumAttributeValidator.new('String', [\"Billable\", \"DoNotBill\", \"NoCharge\", \"NoDefault\"])\n return false unless bill_products_validator.valid?(@bill_products)\n predecessor_type_validator = EnumAttributeValidator.new('String', [\"Ticket\", \"Phase\"])\n return false unless predecessor_type_validator.valid?(@predecessor_type)\n return true\n end",
"def validate!\n true\n end",
"def valid?\n return false if @class_id.nil?\n class_id_validator = EnumAttributeValidator.new('String', [\"vnic.FcIf\"])\n return false unless class_id_validator.valid?(@class_id)\n return false if @object_type.nil?\n object_type_validator = EnumAttributeValidator.new('String', [\"vnic.FcIf\"])\n return false unless object_type_validator.valid?(@object_type)\n return false if !@name.nil? && @name.to_s.length > 31\n return false if !@name.nil? && @name !~ Regexp.new(/^[a-zA-Z0-9\\-\\._:]+$/)\n return false if !@static_wwpn_address.nil? && @static_wwpn_address !~ Regexp.new(/^$|((^20|5[0-9a-fA-F]{1}):([0-9a-fA-F]{2}:){6}([0-9a-fA-F]{2}))/)\n type_validator = EnumAttributeValidator.new('String', [\"fc-initiator\", \"fc-nvme-initiator\", \"fc-nvme-target\", \"fc-target\"])\n return false unless type_validator.valid?(@type)\n return false if !@wwpn.nil? && @wwpn !~ Regexp.new(/^$|((^20|5[0-9a-fA-F]{1}):([0-9a-fA-F]{2}:){6}([0-9a-fA-F]{2}))/)\n wwpn_address_type_validator = EnumAttributeValidator.new('String', [\"POOL\", \"STATIC\"])\n return false unless wwpn_address_type_validator.valid?(@wwpn_address_type)\n true && super\n end",
"def valid?\n validate_survivors and validate_items && validate_records\n end",
"def valid?\n return false if @id.nil?\n return false if @next_send.nil?\n return false if @rrule.nil?\n return false if @session.nil?\n return false if @last_sent.nil?\n return false if @contact_name.nil?\n return false if @parameters.nil?\n return false if @type.nil?\n type_validator = EnumAttributeValidator.new('String', ['Once', 'Hourly', 'Daily', 'Weekly', 'Monthly', 'Yearly'])\n return false unless type_validator.valid?(@type)\n return false if @summary.nil?\n return false if @text_parameters.nil?\n return false if @first_occurrence.nil?\n return false if @last_occurrence.nil?\n return false if @recipients_count.nil?\n return false if @timezone.nil?\n return false if @completed.nil?\n return false if @avatar.nil?\n return false if @created_at.nil?\n true\n end",
"def valid?\n return false if !@description.nil? && @description.to_s.length > 255\n return false if @routing_number.nil?\n return false if @routing_number.to_s.length > 9\n return false if @routing_number.to_s.length < 9\n return false if @account_number.nil?\n return false if @account_number.to_s.length > 17\n return false if @account_type.nil?\n account_type_validator = EnumAttributeValidator.new('String', [\"company\", \"individual\"])\n return false unless account_type_validator.valid?(@account_type)\n return false if @signatory.nil?\n return false if @signatory.to_s.length > 30\n return false if @id.nil?\n return false if @id !~ Regexp.new(/^bank_[a-zA-Z0-9]+$/)\n return false if !@signature_url.nil? && @signature_url !~ Regexp.new(/^https:\\/\\/lob-assets\\.com\\/(letters|postcards|bank-accounts|checks|self-mailers|cards)\\/[a-z]{3,4}_[a-z0-9]{15,16}(\\.pdf|_thumb_[a-z]+_[0-9]+\\.png)\\?(version=[a-z0-9-]*&)?expires=[0-9]{10}&signature=[a-zA-Z0-9_-]+$/)\n return false if @date_created.nil?\n return false if @date_modified.nil?\n return false if @object.nil?\n object_validator = EnumAttributeValidator.new('String', [\"bank_account\"])\n return false unless object_validator.valid?(@object)\n true\n end",
"def valid?\n true\n end",
"def valid?\n true\n end",
"def valid?\n true\n end",
"def valid?\n true\n end",
"def valid?\n return false if @id.nil?\n return false if @account_id.nil?\n return false if @organization_id.nil?\n return false if @product_id.nil?\n return false if @product_rate_plan_id.nil?\n return false if @name.nil?\n type_validator = EnumAttributeValidator.new('String', [\"Subscription\", \"FixedTerm\", \"Trial\"])\n return false unless type_validator.valid?(@type)\n return false if @state.nil?\n state_validator = EnumAttributeValidator.new('String', [\"Trial\", \"Provisioned\", \"Paid\", \"AwaitingPayment\", \"Cancelled\", \"Failed\", \"Expired\"])\n return false unless state_validator.valid?(@state)\n return false if @initial_period_start.nil?\n return false if @trial_end.nil?\n managed_by_validator = EnumAttributeValidator.new('String', [\"BillForward\", \"Stripe\"])\n return false unless managed_by_validator.valid?(@managed_by)\n return false if @version_start.nil?\n return false if @version_number.nil?\n return false if @current_time.nil?\n failed_payment_behaviour_validator = EnumAttributeValidator.new('String', [\"CancelSubscription\", \"None\"])\n return false unless failed_payment_behaviour_validator.valid?(@failed_payment_behaviour)\n return true\n end",
"def validate_fields\n %w[email author].each do |field|\n value = self.send(field)\n abort \"Hoe #{field} value not set. aborting\" if value.nil? or value.empty?\n end\n end",
"def valid?\n return false if @name.nil?\n return false if @name.to_s.length < 1\n return false if @timezone.nil?\n return false if @timezone.to_s.length < 1\n return false if @currency.nil?\n return false if @currency.to_s.length < 1\n case_sensitivity_validator = EnumAttributeValidator.new('String', [\"sensitive\", \"insensitive-uppercase\", \"insensitive-lowercase\"])\n return false unless case_sensitivity_validator.valid?(@case_sensitivity)\n campaign_priority_validator = EnumAttributeValidator.new('String', [\"universal\", \"stackable\", \"exclusive\"])\n return false unless campaign_priority_validator.valid?(@campaign_priority)\n exclusive_campaigns_strategy_validator = EnumAttributeValidator.new('String', [\"listOrder\", \"lowestDiscount\", \"highestDiscount\"])\n return false unless exclusive_campaigns_strategy_validator.valid?(@exclusive_campaigns_strategy)\n default_discount_scope_validator = EnumAttributeValidator.new('String', [\"sessionTotal\", \"cartItems\", \"additionalCosts\"])\n return false unless default_discount_scope_validator.valid?(@default_discount_scope)\n default_discount_additional_cost_per_item_scope_validator = EnumAttributeValidator.new('String', [\"price\", \"itemTotal\", \"additionalCosts\"])\n return false unless default_discount_additional_cost_per_item_scope_validator.valid?(@default_discount_additional_cost_per_item_scope)\n true\n end",
"def valid?\n run_validation\n @errors.empty?\n end",
"def valid?\n MANDATORY_ATTRIBUTES.each{|a| return false unless self[a]}\n true\n end",
"def valid?\n return false if @id.nil?\n return false if @token.nil?\n return false if @tipo.nil?\n tipo_validator = EnumAttributeValidator.new('String', ['fatture', 'proforma', 'ordini', 'preventivi', 'ndc'])\n return false unless tipo_validator.valid?(@tipo)\n return false if @nome.nil?\n return false if @indirizzo_via.nil?\n return false if @indirizzo_cap.nil?\n return false if @indirizzo_citta.nil?\n return false if @indirizzo_provincia.nil?\n return false if @paese.nil?\n lingua_validator = EnumAttributeValidator.new('String', ['it', 'en', 'de'])\n return false unless lingua_validator.valid?(@lingua)\n return false if @piva.nil?\n return false if @cf.nil?\n return false if @numero.nil?\n return false if @valuta.nil?\n return false if @valuta_cambio.nil?\n return false if @prezzi_ivati.nil?\n return false if @importo_netto.nil?\n return false if @importo_iva.nil?\n return false if @importo_totale.nil?\n mostra_totali_validator = EnumAttributeValidator.new('String', ['tutti', 'netto', 'nessuno'])\n return false unless mostra_totali_validator.valid?(@mostra_totali)\n return false if @lista_articoli.nil?\n pa_tipo_cliente_validator = EnumAttributeValidator.new('String', ['PA', 'B2B'])\n return false unless pa_tipo_cliente_validator.valid?(@pa_tipo_cliente)\n pa_tipo_validator = EnumAttributeValidator.new('String', ['ordine', 'convenzione', 'contratto', 'nessuno'])\n return false unless pa_tipo_validator.valid?(@pa_tipo)\n pa_esigibilita_validator = EnumAttributeValidator.new('String', ['I', 'D', 'S', 'N'])\n return false unless pa_esigibilita_validator.valid?(@pa_esigibilita)\n true\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def list_invalid_properties\n invalid_properties = super\n if @class_id.nil?\n invalid_properties.push('invalid value for \"class_id\", class_id cannot be nil.')\n end\n\n if @object_type.nil?\n invalid_properties.push('invalid value for \"object_type\", object_type cannot be nil.')\n end\n\n invalid_properties\n end",
"def valid?\n return false if @name.nil?\n return false if @name.to_s.length > 50\n return false if @prefix_suffix_option.nil?\n prefix_suffix_option_validator = EnumAttributeValidator.new('String', [\"Prefix\", \"Suffix\"])\n return false unless prefix_suffix_option_validator.valid?(@prefix_suffix_option)\n return false if !@invoice_pre_suffix.nil? && @invoice_pre_suffix.to_s.length > 5\n application_units_validator = EnumAttributeValidator.new('String', [\"Amount\", \"Hours\", \"Incidents\"])\n return false unless application_units_validator.valid?(@application_units)\n application_cycle_validator = EnumAttributeValidator.new('String', [\"Contract2Weeks\", \"Contract4Weeks\", \"ContractYear\", \"CalendarMonth\", \"CalendarQuarter\", \"CalendarWeek\", \"ContractQuarter\", \"CalendarYear\"])\n return false unless application_cycle_validator.valid?(@application_cycle)\n return false if @employee_comp_rate.nil?\n employee_comp_rate_validator = EnumAttributeValidator.new('String', [\"Actual\", \"Hourly\"])\n return false unless employee_comp_rate_validator.valid?(@employee_comp_rate)\n return false if @employee_comp_not_exceed.nil?\n employee_comp_not_exceed_validator = EnumAttributeValidator.new('String', [\"Billing\", \"Percent\", \"Amount\"])\n return false unless employee_comp_not_exceed_validator.valid?(@employee_comp_not_exceed)\n return false if @invoicing_cycle.nil?\n invoicing_cycle_validator = EnumAttributeValidator.new('String', [\"CalendarYear\", \"ContractYear\"])\n return false unless invoicing_cycle_validator.valid?(@invoicing_cycle)\n return false if !@invoice_description.nil? && @invoice_description.to_s.length > 4000\n return false if @bill_time.nil?\n bill_time_validator = EnumAttributeValidator.new('String', [\"Billable\", \"DoNotBill\", \"NoCharge\", \"NoDefault\"])\n return false unless bill_time_validator.valid?(@bill_time)\n return false if @bill_expenses.nil?\n bill_expenses_validator = EnumAttributeValidator.new('String', [\"Billable\", \"DoNotBill\", \"NoCharge\", \"NoDefault\"])\n return false unless bill_expenses_validator.valid?(@bill_expenses)\n return false if @bill_products.nil?\n bill_products_validator = EnumAttributeValidator.new('String', [\"Billable\", \"DoNotBill\", \"NoCharge\", \"NoDefault\"])\n return false unless bill_products_validator.valid?(@bill_products)\n return true\n end",
"def validate\n end",
"def valid?\n return false if @to.nil?\n return false if @from.nil?\n carrier_validator = EnumAttributeValidator.new('String', [\"USPS\"])\n return false unless carrier_validator.valid?(@carrier)\n return false if @date_created.nil?\n return false if @date_modified.nil?\n return false if @id.nil?\n return false if @id !~ Regexp.new(/^ltr_[a-zA-Z0-9]+$/)\n return false if !@template_id.nil? && @template_id !~ Regexp.new(/^tmpl_[a-zA-Z0-9]+$/)\n return false if !@template_version_id.nil? && @template_version_id !~ Regexp.new(/^vrsn_[a-zA-Z0-9]+$/)\n return false if !@url.nil? && @url !~ Regexp.new(/^https:\\/\\/(lob-assets|lob-assets-staging)\\.com\\/(letters|postcards|bank-accounts|checks|self-mailers|cards)\\/[a-z]{3,4}_[a-z0-9]{15,16}(\\.pdf|_thumb_[a-z]+_[0-9]+\\.png)\\?(version=[a-z0-9-]*&)?expires=[0-9]{10}&signature=[a-zA-Z0-9_-]+$/)\n return false if @object.nil?\n object_validator = EnumAttributeValidator.new('String', [\"letter\"])\n return false unless object_validator.valid?(@object)\n return false if !@description.nil? && @description.to_s.length > 255\n return false if !@tracking_events.nil? && @tracking_events.length > 0\n address_placement_validator = EnumAttributeValidator.new('String', [\"top_first_page\", \"insert_blank_page\", \"bottom_first_page_center\", \"bottom_first_page\"])\n return false unless address_placement_validator.valid?(@address_placement)\n true\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def valid_attributes\n {}\n end",
"def supports_validations?\n true\n end",
"def valid?\n @errors = self.class.valid_against_schema?(self.class.json_schema, self)\n @errors.empty?\n end",
"def valid?\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n end",
"def valid?\n return false if @first_name.nil?\n return false if @first_name.to_s.length > 30\n return false if !@last_name.nil? && @last_name.to_s.length > 30\n return false if !@address_line1.nil? && @address_line1.to_s.length > 50\n return false if !@address_line2.nil? && @address_line2.to_s.length > 50\n return false if !@city.nil? && @city.to_s.length > 50\n return false if !@state.nil? && @state.to_s.length > 50\n return false if !@zip.nil? && @zip.to_s.length > 12\n return false if !@country.nil? && @country.to_s.length > 50\n return false if !@security_identifier.nil? && @security_identifier.to_s.length > 184\n return false if !@title.nil? && @title.to_s.length > 100\n return false if !@school.nil? && @school.to_s.length > 50\n return false if !@nick_name.nil? && @nick_name.to_s.length > 30\n return false if !@significant_other.nil? && @significant_other.to_s.length > 30\n return false if !@portal_password.nil? && @portal_password.to_s.length > 15\n return false if !@portal_security_level.nil? && @portal_security_level > 6.0\n return false if !@portal_security_level.nil? && @portal_security_level < 1.0\n gender_validator = EnumAttributeValidator.new('String', [\"Male\", \"Female\"])\n return false unless gender_validator.valid?(@gender)\n presence_validator = EnumAttributeValidator.new('String', [\"Online\", \"DoNotDisturb\", \"Away\", \"Offline\", \"NoAgent\"])\n return false unless presence_validator.valid?(@presence)\n return true\n end",
"def validated?; end",
"def valid?\n return false if @name.nil?\n return false if @slug.nil?\n return false if @status.nil?\n status_validator = EnumAttributeValidator.new('String', ['enabled', 'disabled'])\n return false unless status_validator.valid?(@status)\n return false if @type.nil?\n type_validator = EnumAttributeValidator.new('String', ['digital', 'physical'])\n return false unless type_validator.valid?(@type)\n return false if @sku.nil?\n return false if @price.nil?\n availability_validator = EnumAttributeValidator.new('String', ['available', 'comingSoon', 'retired'])\n return false unless availability_validator.valid?(@availability)\n stock_status_validator = EnumAttributeValidator.new('String', ['available', 'alert', 'unavailable'])\n return false unless stock_status_validator.valid?(@stock_status)\n return false if @categories.nil?\n true\n end",
"def valid?\n self.valid\n end",
"def valid?\n true\n end",
"def valid?\n true\n end",
"def valid?\n true\n end",
"def valid?\n true\n end"
] |
[
"0.78992486",
"0.78992486",
"0.70971805",
"0.70782334",
"0.7032205",
"0.7031276",
"0.69510347",
"0.6869891",
"0.6858077",
"0.6858077",
"0.68287027",
"0.6823878",
"0.6820306",
"0.68144894",
"0.6794656",
"0.6752167",
"0.66843414",
"0.6676546",
"0.6667755",
"0.66296124",
"0.66184515",
"0.6608204",
"0.6599208",
"0.6594276",
"0.6584302",
"0.6580472",
"0.6578095",
"0.6558585",
"0.6555879",
"0.6542414",
"0.6536983",
"0.6533884",
"0.65315515",
"0.65311855",
"0.65267456",
"0.65258855",
"0.6520786",
"0.65205675",
"0.6511026",
"0.6498394",
"0.64966303",
"0.64935124",
"0.6491113",
"0.64885867",
"0.6479024",
"0.6473706",
"0.64679337",
"0.6467217",
"0.6461245",
"0.64601135",
"0.64553183",
"0.64540446",
"0.6447954",
"0.64393955",
"0.6434162",
"0.64312094",
"0.6428205",
"0.6426148",
"0.6412439",
"0.64070046",
"0.64044213",
"0.6403482",
"0.6399368",
"0.63979715",
"0.63858813",
"0.63855004",
"0.63855004",
"0.63855004",
"0.63855004",
"0.63740236",
"0.6367379",
"0.63645166",
"0.6362151",
"0.63599974",
"0.6357385",
"0.63549066",
"0.63549066",
"0.63549066",
"0.63549066",
"0.6354845",
"0.6354207",
"0.6350302",
"0.6344303",
"0.6344303",
"0.6344303",
"0.6344303",
"0.6344303",
"0.6344303",
"0.6344303",
"0.6344303",
"0.63435715",
"0.63406414",
"0.63344824",
"0.6333158",
"0.63313466",
"0.63294095",
"0.6327076",
"0.63247603",
"0.63247603",
"0.63247603",
"0.63247603"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def title=(title)
if title.nil?
fail ArgumentError, 'title cannot be nil'
end
if title.to_s.length < 1
fail ArgumentError, 'invalid value for "title", the character length must be great than or equal to 1.'
end
@title = title
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def method_missing(method_name, *args)\n method_match, attribute_name, equal_sign = method_name.to_s.match(/\\A([^=]+)(=)?\\Z/).to_a\n if attribute_name && self.class.valid_attributes.include?(attribute_name.to_sym)\n if equal_sign \n attributes[attribute_name.to_sym] = args.first\n else\n attributes[attribute_name.to_sym]\n end\n else\n super\n end\n end",
"def attribute; end"
] |
[
"0.64708173",
"0.63147706",
"0.63147706",
"0.62832147",
"0.6279096",
"0.6211268",
"0.6187812",
"0.6180797",
"0.6068028",
"0.6033098",
"0.59972554",
"0.59903276",
"0.596004",
"0.59378564",
"0.59287316",
"0.58953243",
"0.5859936",
"0.58510554",
"0.58483785",
"0.58452195",
"0.583343",
"0.5823432",
"0.5823189",
"0.5784625",
"0.57034314",
"0.5696107",
"0.5680822",
"0.5678617",
"0.5665916",
"0.5655935",
"0.565553",
"0.5640707",
"0.5621132",
"0.56144834",
"0.5610037",
"0.55987394",
"0.55970824",
"0.5594733",
"0.5584827",
"0.5583628",
"0.5581201",
"0.5569362",
"0.55665964",
"0.55655104",
"0.5565303",
"0.5563756",
"0.5559642",
"0.5558446",
"0.5558446",
"0.55532336",
"0.55532336",
"0.5538853",
"0.5534503",
"0.55265135",
"0.55264664",
"0.5523125",
"0.55027425",
"0.5497696",
"0.5497053",
"0.549249",
"0.5463915",
"0.5462299",
"0.54614836",
"0.54509217",
"0.54490197",
"0.54490197",
"0.54358697",
"0.54297453",
"0.54297453",
"0.5425442",
"0.54183954",
"0.54147303",
"0.541028",
"0.5406863",
"0.5401083",
"0.54007477",
"0.53988314",
"0.5391773",
"0.5382439",
"0.53770405",
"0.5375866",
"0.5374248",
"0.53707117",
"0.53681",
"0.53626144",
"0.5361229",
"0.5358391",
"0.5350761",
"0.53502077",
"0.5349265",
"0.53460044",
"0.53430027",
"0.5328167",
"0.5328167",
"0.53215694",
"0.53215694",
"0.53215694",
"0.5319428",
"0.5318167",
"0.53138155",
"0.5313695"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def image=(image)
if image.nil?
fail ArgumentError, 'image cannot be nil'
end
if image.to_s.length < 1
fail ArgumentError, 'invalid value for "image", the character length must be great than or equal to 1.'
end
@image = image
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def image_type=(image_type)
if image_type.nil?
fail ArgumentError, 'image_type cannot be nil'
end
if image_type.to_s.length < 1
fail ArgumentError, 'invalid value for "image_type", the character length must be great than or equal to 1.'
end
@image_type = image_type
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def license=(license)
if license.nil?
fail ArgumentError, 'license cannot be nil'
end
if license.to_s.length < 1
fail ArgumentError, 'invalid value for "license", the character length must be great than or equal to 1.'
end
@license = license
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def source_name=(source_name)
if source_name.nil?
fail ArgumentError, 'source_name cannot be nil'
end
if source_name.to_s.length < 1
fail ArgumentError, 'invalid value for "source_name", the character length must be great than or equal to 1.'
end
@source_name = source_name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def method_missing(method_name, *args)\n method_match, attribute_name, equal_sign = method_name.to_s.match(/\\A([^=]+)(=)?\\Z/).to_a\n if attribute_name && self.class.valid_attributes.include?(attribute_name.to_sym)\n if equal_sign \n attributes[attribute_name.to_sym] = args.first\n else\n attributes[attribute_name.to_sym]\n end\n else\n super\n end\n end",
"def attribute; end"
] |
[
"0.64708173",
"0.63147706",
"0.63147706",
"0.62832147",
"0.6279096",
"0.6211268",
"0.6187812",
"0.6180797",
"0.6068028",
"0.6033098",
"0.59972554",
"0.59903276",
"0.596004",
"0.59378564",
"0.59287316",
"0.58953243",
"0.5859936",
"0.58510554",
"0.58483785",
"0.58452195",
"0.583343",
"0.5823432",
"0.5823189",
"0.5784625",
"0.57034314",
"0.5696107",
"0.5680822",
"0.5678617",
"0.5665916",
"0.5655935",
"0.565553",
"0.5640707",
"0.5621132",
"0.56144834",
"0.5610037",
"0.55987394",
"0.55970824",
"0.5594733",
"0.5584827",
"0.5583628",
"0.5581201",
"0.5569362",
"0.55665964",
"0.55655104",
"0.5565303",
"0.5563756",
"0.5559642",
"0.5558446",
"0.5558446",
"0.55532336",
"0.55532336",
"0.5538853",
"0.5534503",
"0.55265135",
"0.55264664",
"0.5523125",
"0.55027425",
"0.5497696",
"0.5497053",
"0.549249",
"0.5463915",
"0.5462299",
"0.54614836",
"0.54509217",
"0.54490197",
"0.54490197",
"0.54358697",
"0.54297453",
"0.54297453",
"0.5425442",
"0.54183954",
"0.54147303",
"0.541028",
"0.5406863",
"0.5401083",
"0.54007477",
"0.53988314",
"0.5391773",
"0.5382439",
"0.53770405",
"0.5375866",
"0.5374248",
"0.53707117",
"0.53681",
"0.53626144",
"0.5361229",
"0.5358391",
"0.5350761",
"0.53502077",
"0.5349265",
"0.53460044",
"0.53430027",
"0.5328167",
"0.5328167",
"0.53215694",
"0.53215694",
"0.53215694",
"0.5319428",
"0.5318167",
"0.53138155",
"0.5313695"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def source_url=(source_url)
if source_url.nil?
fail ArgumentError, 'source_url cannot be nil'
end
if source_url.to_s.length < 1
fail ArgumentError, 'invalid value for "source_url", the character length must be great than or equal to 1.'
end
@source_url = source_url
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def spoonacular_source_url=(spoonacular_source_url)
if spoonacular_source_url.nil?
fail ArgumentError, 'spoonacular_source_url cannot be nil'
end
if spoonacular_source_url.to_s.length < 1
fail ArgumentError, 'invalid value for "spoonacular_source_url", the character length must be great than or equal to 1.'
end
@spoonacular_source_url = spoonacular_source_url
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def credits_text=(credits_text)
if credits_text.nil?
fail ArgumentError, 'credits_text cannot be nil'
end
if credits_text.to_s.length < 1
fail ArgumentError, 'invalid value for "credits_text", the character length must be great than or equal to 1.'
end
@credits_text = credits_text
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def gaps=(gaps)
if gaps.nil?
fail ArgumentError, 'gaps cannot be nil'
end
if gaps.to_s.length < 1
fail ArgumentError, 'invalid value for "gaps", the character length must be great than or equal to 1.'
end
@gaps = gaps
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def method_missing(method_name, *args)\n method_match, attribute_name, equal_sign = method_name.to_s.match(/\\A([^=]+)(=)?\\Z/).to_a\n if attribute_name && self.class.valid_attributes.include?(attribute_name.to_sym)\n if equal_sign \n attributes[attribute_name.to_sym] = args.first\n else\n attributes[attribute_name.to_sym]\n end\n else\n super\n end\n end",
"def attribute; end"
] |
[
"0.64708173",
"0.63147706",
"0.63147706",
"0.62832147",
"0.6279096",
"0.6211268",
"0.6187812",
"0.6180797",
"0.6068028",
"0.6033098",
"0.59972554",
"0.59903276",
"0.596004",
"0.59378564",
"0.59287316",
"0.58953243",
"0.5859936",
"0.58510554",
"0.58483785",
"0.58452195",
"0.583343",
"0.5823432",
"0.5823189",
"0.5784625",
"0.57034314",
"0.5696107",
"0.5680822",
"0.5678617",
"0.5665916",
"0.5655935",
"0.565553",
"0.5640707",
"0.5621132",
"0.56144834",
"0.5610037",
"0.55987394",
"0.55970824",
"0.5594733",
"0.5584827",
"0.5583628",
"0.5581201",
"0.5569362",
"0.55665964",
"0.55655104",
"0.5565303",
"0.5563756",
"0.5559642",
"0.5558446",
"0.5558446",
"0.55532336",
"0.55532336",
"0.5538853",
"0.5534503",
"0.55265135",
"0.55264664",
"0.5523125",
"0.55027425",
"0.5497696",
"0.5497053",
"0.549249",
"0.5463915",
"0.5462299",
"0.54614836",
"0.54509217",
"0.54490197",
"0.54490197",
"0.54358697",
"0.54297453",
"0.54297453",
"0.5425442",
"0.54183954",
"0.54147303",
"0.541028",
"0.5406863",
"0.5401083",
"0.54007477",
"0.53988314",
"0.5391773",
"0.5382439",
"0.53770405",
"0.5375866",
"0.5374248",
"0.53707117",
"0.53681",
"0.53626144",
"0.5361229",
"0.5358391",
"0.5350761",
"0.53502077",
"0.5349265",
"0.53460044",
"0.53430027",
"0.5328167",
"0.5328167",
"0.53215694",
"0.53215694",
"0.53215694",
"0.5319428",
"0.5318167",
"0.53138155",
"0.5313695"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def extended_ingredients=(extended_ingredients)
if !extended_ingredients.nil? && extended_ingredients.length < 0
fail ArgumentError, 'invalid value for "extended_ingredients", number of items must be greater than or equal to 0.'
end
@extended_ingredients = extended_ingredients
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Custom attribute writer method with validation
|
def summary=(summary)
if summary.nil?
fail ArgumentError, 'summary cannot be nil'
end
if summary.to_s.length < 1
fail ArgumentError, 'invalid value for "summary", the character length must be great than or equal to 1.'
end
@summary = summary
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_writer_tag(text); end",
"def allowed_attributes=(_arg0); end",
"def allowed_attributes=(_arg0); end",
"def writer(*args)\n attr_writer(*args)\n args\n end",
"def define_write_method(attr_name)\n evaluate_attribute_method attr_name, \"def #{attr_name}=(new_value);write_attribute('#{attr_name}', new_value);end\", \"#{attr_name}=\"\n end",
"def attr_writer(*vars)\n # avoid tracking attributes that are added by the class_attribute\n # as these are class attributes and not instance attributes.\n tracked_vars = vars.reject {|var| respond_to? var }\n add_tracked_attrs(false, true, *tracked_vars)\n vars.extract_options!\n super\n end",
"def attr_writer(sym, *more) end",
"def is_attribute?; end",
"def validate_exclusion_of(attr); end",
"def register_attributes\n raise \"Not implemented in #{self.class}\"\n end",
"def method_missing(method_name, *args)\n return super unless permitted_attributes.include?(method_name)\n begin\n object.send(:\"#{method_name}=\", args.first)\n rescue => e\n if params.has_key?(method_name)\n message = \"Unable to process value for :#{method_name}, no attribute writer. Be sure to override the automatic setters for all params that do not map straight to a model attribute.\"\n Rails.logger.warn({message: message,\n missing_writer: method_name,\n value: args.first,\n error: e})\n self.errors << {status: 422, message: message}\n else\n raise e\n end\n end\n end",
"def timeliness_validation_for(attr_names, type)\n super\n attr_names.each { |attr_name| define_timeliness_write_method(attr_name) }\n end",
"def create_setter_for(attribute, options)\n setter_method = \"#{attribute}=\"\n\n define_method setter_method do |value|\n if options[:allow_blank] || value != \"\"\n write_attribute(attribute, value)\n end\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}\n end",
"def escape_attr input\n escape input, attr_regexp, attr_mapping\n end",
"def make_writer( attrtype )\n\t\tself.log.debug \"Generating an attribute writer for %p\" % [ attrtype ]\n\t\tattrname = attrtype.name\n\t\tif attrtype.single?\n\t\t\tself.log.debug \" attribute is SINGLE, so generating a scalar writer...\"\n\t\t\treturn lambda {|newvalue| self[attrname] = newvalue }\n\t\telse\n\t\t\tself.log.debug \" attribute isn't SINGLE, so generating an array writer...\"\n\t\t\treturn lambda {|*newvalues| self[attrname] = newvalues.flatten }\n\t\tend\n\tend",
"def write_attribute(name, value)\n # Simply check if the accessor is allowed to write the field\n # (if so, go to superclass and do it)\n @bypass_auth ||= false\n if allowed_to_write(name) || @bypass_auth\n super(name, value)\n end\n end",
"def mattr_writer(*syms, &proc)\n receiver = self\n options = syms.extract_options!\n syms.each do |sym|\n raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\\w*$/\n class_exec do\n define_singleton_method \"#{sym}=\" do |obj|\n class_variable_set(\"@@#{sym}\", obj)\n end\n end\n\n unless options[:instance_writer] == false || options[:instance_accessor] == false\n class_exec do\n define_method \"#{sym}=\" do |obj|\n receiver.class_variable_set(\"@@#{sym}\", obj)\n end\n end\n end\n send(\"#{sym}=\", proc.call) if proc\n end\n end",
"def write_attribute(attribute, value)\n false\n end",
"def add_attribute attribute\n return attribute unless @document_self\n\n # mainly to check for redefinition of an attribute as a method\n # TODO find a policy for 'attr_reader :foo' + 'def foo=()'\n register = false\n\n key = nil\n\n if attribute.rw.index 'R' then\n key = attribute.pretty_name\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name + '='] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if attribute.rw.index 'W' then\n key = attribute.pretty_name + '='\n known = @methods_hash[key]\n\n if known then\n known.comment = attribute.comment if known.comment.empty?\n elsif registered = @methods_hash[attribute.pretty_name] and\n RDoc::Attr === registered then\n registered.rw = 'RW'\n else\n @methods_hash[key] = attribute\n register = true\n end\n end\n\n if register then\n attribute.visibility = @visibility\n add_to @attributes, attribute\n resolve_aliases attribute\n end\n\n attribute\n end",
"def define_writer_method(mod)\n writer_method_name = \"#{name}=\"\n attribute = self\n\n mod.send(:define_method, writer_method_name) { |value| attribute.set(self, value) }\n mod.send(writer_visibility, writer_method_name)\n\n self\n end",
"def allowed_to_write(name)\n # no point allowing attribute writes if we can't save them?\n if allowed_to_save\n name = name.to_s\n validation_methods = self.class.write_validations(name) \n if validation_methods.nil?\n # We haven't registered any filters on this attribute, so allow the write.\n true\n elsif validation_methods.check :accessor => accessor, :model => self\n # One of the authentication methods worked, so allow the write.\n true\n else\n # We had filters but none of them passed. Disallow write.\n false\n end\n else\n false\n end\n end",
"def assert_attr_writer(obj, method)\n assert_respond_to obj, \"#{method}=\"\nend",
"def add_attribute(name, &block); end",
"def authenticates_writes_to(attr, options={})\n authenticates_access\n @write_validation_map ||= {}\n @write_validation_map[attr.to_s] ||= AuthMethodList.new\n @write_validation_map[attr.to_s].add_method(options)\n end",
"def write_attribute_3(param1, param2)\n\twrite_attribute(param1, param2)\n end",
"def write_attribute(attr_name, value) #:doc:\n @attributes[attr_name] = empty_string_for_number_column?(attr_name, value) ? nil : value\n end",
"def add_writer_tags(klass, new_method, member)\n member_tag = member_tag_for_member(klass, member, :write)\n return_type = return_type_from_tag(member_tag)\n setter_doc_text = member_tag ? member_tag.text : \"Sets the attribute #{member}\"\n new_method.docstring.replace(setter_doc_text)\n new_method.add_tag YARD::Tags::Tag.new(:param, \"the value to set the attribute #{member} to.\", return_type, \"value\")\n new_method.add_tag YARD::Tags::Tag.new(:return, \"the newly set value\", return_type)\n end",
"def print_attribute(*) end",
"def attribute(name); end",
"def add_checked_attribute(clazz, attribute)\r\n eval <<END\r\n class #{clazz}\r\n\r\n def #{attribute}=(value)\r\n raise 'Invalid attribute' unless value\r\n @#{attribute}=value\r\n end\r\n\r\n def #{attribute}\r\n #{attribute}\r\n end\r\n end\r\nEND\r\nend",
"def attr(name); end",
"def is_attribute?(line)\n (line =~ /(\\s+)attr_(writer|reader|accessor)\\s+:[a-zA-Z_0-9]+/) == 0\n end",
"def attribute(name, value)\n\t if !@inStartTag\n\t\traise WriterError.new('attribute outside of tag start')\n\t end\n\t @io << \" #{name}=\\\"#{NQXML.encode(value.to_s)}\\\"\"\n\tend",
"def set_attribute(name, value); end",
"def dataset_writer(*attributes)\n attributes.flatten.each do |attr_name|\n next if method_defined?(\"#{attr_name}=\")\n\n class_eval <<-RUBY, __FILE__, __LINE__ + 1\n def #{attr_name}=(value)\n dataset_set(:#{attr_name}, value)\n end\n RUBY\n end\n end",
"def validated_attribute_names(params); end",
"def require_format_of(attribute)\r\n RequireFormatOf.new(attribute)\r\n end",
"def attr_writer(*fields)\n check_fields(fields)\n added_fields = jiak.data.writable(*fields)\n added_fields.each do |field|\n class_eval <<-EOM\n def #{field}=(val)\n @jiak.object.data.#{field} = val\n self.class.do_auto_update(self)\n end\n EOM\n end\n nil\n end",
"def html_attr(*attrs)\n options = attrs.extract_options!.reverse_merge({\n :level => :super_relaxed\n })\n attrs.each do |att|\n class_eval \"def #{att}=(val); self[:#{att}] = sanitize(val, :#{options[:level]}); end\"\n end\n end",
"def validate_attributes=(new_attribute)\n @validate_attributes = new_attribute\n end",
"def html_attributes(attr); end",
"def instance_write(attr, value)\n setter = :\"#{@name_string}_#{attr}=\"\n instance.send(setter, value) if instance.respond_to?(setter)\n end",
"def valid_xml_attribute(name, options={:level => :warning})\n\t\t\t\tvalidate(\"Invalid XML attribute '#{name}'\", options) { name.to_s.match(/^([^[:punct:]0-9<>]|_)[^<>\"']*/) }\n\t\t\tend",
"def attr_writer(*args)\n sym_args=args_to_sym(args)\n sym_args.each do |value|\n self.instance_eval(\"def #{value}=(arg); @#{value}=arg;end;\")\n end\n \n end",
"def define_writer_method(attribute, method_name, visibility)\n define_method(method_name) { |value| attribute.set(self, value) }\n send(visibility, method_name)\n self\n end",
"def write_attribute(name, val)\n if @embedded_models.include? name\n @embedded_models[name].model = val\n elsif @attribute_objects.include? name\n @attribute_objects[name].value = val\n else\n return false\n end\n\n run_callbacks :attribute_change\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { \"name\" => \"MyString\" }\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def valid_attributes\n { body: \"blah\",\n rule_text: 'Something',\n change_description: \"blaa\"}\n end",
"def attr; end",
"def attribute(*args)\n define_expressions(Attribute, args)\n end",
"def write_attribute(name, value)\n name = name.to_s\n\n # The attribute already has an unsaved change.\n if attribute_changed?(name)\n old = changed_attributes[name]\n changed_attributes.delete(name) unless field_changed?(name, old, value)\n else\n attribute_will_change(name) if field_changed?(name, old, value)\n end\n\n # Carry on.\n super(name, value)\n end",
"def define_magic_attr(name)\n define_method name do |*attrs|\n raise ArgumentError.new(\"wrong number of arguments\") if attrs.size > 1\n send(\"#{name}=\", attrs.first) if attrs.size == 1\n instance_variable_get(\"@#{name}\")\n end\n\n attr_writer name\n end",
"def configurable_writer(attribute, code=nil, &block)\n if block_given? and not code\n Halcyon.class.send(:define_method, :\"#{attribute}=\", block)\n elsif code and not block_given?\n Halcyon.class.send(:eval, <<-\"end;\")\n def #{attribute.to_s}=(value)\n #{code % [attribute.to_sym.inspect]}\n end\n end;\n else\n raise ArgumentError.new(\"Either a block or a code string should be supplied.\")\n end\n end",
"def method_missing(name, *args, &block)\n if /\\Ahas_validated_(?<type>\\w*)_attribute\\Z/ =~ name\n has_validated_attribute(type, *args, &block)\n else\n super\n end\n end",
"def add_checked_attribute(klass, attribute)\n klass.class_eval do\n define_method attribute do\n instance_variable_get(\"@#{attribute}\")\n end\n\n define_method \"#{attribute}=\" do |value|\n raise 'Invalid attribute' unless value\n \n instance_variable_set(\"@#{attribute}\", value)\n end\n end\nend",
"def method_missing(meth, *args, &blk)\n match = meth.to_s.match(/^([a-zA-Z\\_]+)(=|$)$/)\n if match\n attribute, setter = match[1], !match[2].blank?\n if setter\n write_attribute(attribute, args.first)\n else\n read_attribute(attribute)\n end\n else\n super(meth, *args, &blk)\n end\n end",
"def valid_attributes\n { name: 'do this' }\n end",
"def make_attributes_definitions_or_croak(attrArgs, &attrBlok)\n eye = :'m_attrs_defs'\n\n # Work with attribute as strings\n \n $DEBUG && logger_me(eye, logger_fmt_kls(:attrArgs => attrArgs, :attrBlok => attrBlok))\n\n mustbe_attributes_specification_or_croak(attrArgs, eye, \"attrArgs not attributes_specification\")\n \n #STOPATTRARGSINSUPER\n \n #attrAll = mustbe_not_empty_or_croak(mustbe_array_key_or_nil_or_croak(attrArgs, :all, eye, \"all attributes not array\"), eye, \"all attributes is empty\").map(&:to_s)\n attrAll = mustbe_not_empty_or_croak(mustbe_attributes_specification_all_key_or_croak(attrArgs, :all, eye), eye, \"all attributes is empty\").map(&:to_s)\n \n\n #puts(\"\\n\\n\\nATTR ALL >#{attrAll}<\")\n\n #STOPMAKEATTRSPECSENTRY\n\n attrInc = mustbe_attributes_specification_include_key_or_nil_or_croak(attrArgs, :include, eye) # mustbe all strings\n #puts(\"ATTR INC >#{attrInc.class}< >#{attrInc}< >#{is_value_not_empty?(attrInc)}<\")\n attrInc && mustbe_not_empty_or_croak(attrInc, eye, \"include attributes is empty\")\n\n attrExc = mustbe_attributes_specification_exclude_key_or_nil_or_croak(attrArgs, :exclude, eye) || []\n \n attrMapNom = mustbe_attributes_definitions_key_or_nil_or_croak(attrArgs, :definitions, eye) || {}\n attrMap = attrMapNom && potrubi_util_map_hash_kv(attrMapNom) {|k,v| [k.to_s, v]} # keys all strings\n\n # Ensure all consistent\n \n attrInc && mustbe_subset_or_croak(attrInc, attrAll, eye, \"include attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrExc, attrAll, eye, \"exclude attributes contains unknown attributes\")\n mustbe_subset_or_croak(attrMap.keys, attrAll, eye, \"attribute map contains unknown attributes\")\n \n attrUse = ((attrInc || attrAll) - attrExc).uniq # list of unique attributes to report on\n\n # consolidate \"faked up\" attr specs with ones provided to get the composite attrSpecs\n \n attrDefsNom = potrubi_util_array_to_hash(attrUse).merge(attrMap.select {|k,v| attrUse.include?(k)}) # consolidated \"faked up\" attr specs with ones provided\n\n attrDefs = potrubi_util_map_hash_v(attrDefsNom) do | attrName, attrSpecNom|\n\n attrSpec =\n case attrSpecNom\n when NilClass then {}\n when Hash then\n attrSpecNom.each_with_object({}) do | (verbName, verbSpec), h1 |\n case verbName\n when :pass_thru then h1[:pass_thru] = verbSpec # dont touch; just pass through\n when :event_defaults then # add these to pass_thru\n h1[:pass_thru] = (h1[:pass_thru] || {}).merge(verbName => verbSpec)\n when :map, :select, :metric then\n h1[verbName] = {\n :method_name => \"#{verbName}_#{attrName}_#{rand(1000000)}\", # make a unqiue name\n :method_spec => verbSpec # spec must be valid to dynamic_define_methods\n }\n else\n logic_exception(verbName, eye, \"attrName >#{attrName}< verbName >#{verbName}< value should be impossible\")\n end\n end\n \n else\n logic_exception(attrrSpecNom, eye, \"attrSpecNom value should be impossible\")\n end\n\n attrSpec\n \n end\n \n $DEBUG && logger_mx(eye, logger_fmt_kls(:attrDefs => attrDefs))\n\n mustbe_attributes_definitions_or_croak(attrDefs, eye, \"attrDefs failed contract\")\n\n #STOPMAKEATTRSPECS\n \n end",
"def create_writer(klass, member)\n # We want to convert these members into attributes just like\n # as if they were declared using attr_accessor.\n new_meth = register MethodObject.new(klass, \"#{member}=\", :instance) do |o|\n o.parameters = [['value', nil]]\n o.signature ||= \"def #{member}=(value)\"\n o.source ||= \"#{o.signature}\\n @#{member} = value\\nend\"\n end\n add_writer_tags(klass, new_meth, member)\n klass.attributes[:instance][member][:write] = new_meth\n end",
"def create_setter!\n @target.class_eval <<-EOS\n #{writer_visibility.to_s}\n def #{name}=(value)\n attribute_set(#{name.inspect}, value)\n end\n EOS\n rescue SyntaxError\n raise SyntaxError.new(column)\n end",
"def attribute name, type, conditions= DEFAULT_ATTRIBUTE_CONDITIONS\n RMOF.complete_conditions conditions, DEFAULT_ATTRIBUTE_CONDITIONS\n @attributes= {} unless instance_variable_defined? :@attributes\n @attributes[name]= [name, type, conditions]\n unless method_defined? :__attributes then \n define_method( :__attributes) do \n @attributes\n end \n end\n at= \"@#{name}\".to_sym\n getter= \"#{name}\".to_sym\n setter= \"#{name}=\".to_sym\n completion= \"__complete_#{name}\".to_sym\n define_method( getter) do\n if instance_variable_defined? at then instance_variable_get at\n else conditions[:default]\n end\n end\n define_method( setter) do |val|\n instance_variable_set at, val\n end\n define_method( completion) do\n RMOF.validate( self.send(getter), name, type, conditions)\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def attr_internal_writer(*attrs)\n attrs.each do |attr|\n module_eval \"def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end\"\n end\n end",
"def create_setter(name, meth)\n define_method(\"#{meth}=\") do |value|\n write_attribute(name, value)\n end\n end",
"def sanitized_allowed_attributes=(attributes); end",
"def sanitized_allowed_attributes=(attributes); end",
"def oattr(name, type)\n case type\n when :custom\n # Do nothing, just register attr below.\n when :writer\n attr_writer name\n else\n raise ArgumentError, \"Unknown type: #{type.inspect}\"\n end\n\n # Register and return.\n name.tap { oattrs << name}\n end",
"def valid_attributes\n { name: \"Expert\" }\n end",
"def attributes(*method_names, **options)\n add_attributes(method_names, **options, strategy: :write_value_using_method_strategy)\n end",
"def []=(attr_name, value)\n writer_method = \"#{attr_name}=\"\n send(writer_method, value) if respond_to?(writer_method)\n end",
"def write_extended_attributes(attrs)\n attrs.each do |k, val|\n self.send((k.to_s + \"=\").to_sym, val) if is_flex_attribute?(k)\n end\n self\n end",
"def valid_attributes\n { \"username\" => \"MyString\" }\n end",
"def cattr_writer(*fields)\n metaclass.send :attr_writer, *fields\n end",
"def write_attribute(attr, value)\n if attribute_encrypted?(attr)\n conductor_for(attr).encrypt(value)\n else\n super(attr, value)\n end\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_number_value(\"offsetInDays\", @offset_in_days)\n writer.write_enum_value(\"timeBasedAttribute\", @time_based_attribute)\n end",
"def define_attribute_method(attr_name, _owner: generated_attribute_methods)\n CodeGenerator.batch(_owner, __FILE__, __LINE__) do |owner|\n attribute_method_matchers.each do |matcher|\n method_name = matcher.method_name(attr_name)\n\n unless instance_method_already_implemented?(method_name)\n generate_method = \"define_method_#{matcher.target}\"\n\n if respond_to?(generate_method, true)\n send(generate_method, attr_name.to_s, owner: owner)\n else\n define_proxy_call true, owner, method_name, matcher.target, attr_name.to_s\n end\n end\n end\n attribute_method_matchers_cache.clear\n end\n end",
"def has_attributes?; end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n super\n writer.write_boolean_value(\"isExpirationRequired\", @is_expiration_required)\n writer.write_duration_value(\"maximumDuration\", @maximum_duration)\n end",
"def add_attributes(item)\n [:class, :instance].each do |attr_loc|\n # Grab attributes for the current location (class or instance)\n attrs = item.attributes[attr_loc]\n attrs.each do |name, attribute|\n reader = attribute[:read]\n writer = attribute[:write]\n\n unless reader || writer\n Logging.warn(\"attribute is not readable or writable somehow, skipping\", attribute)\n next\n end\n\n # Get all given types\n yard_types = []\n if reader\n next if @hide_private && reader.visibility == :private\n yard_types += reader.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n reader.tags('param').flat_map(&:types)\n end\n if writer\n next if @hide_private && writer.visibility == :private\n yard_types += writer.tags('return').flat_map(&:types).compact.reject { |x| x.downcase == 'void' } +\n writer.tags('param').flat_map(&:types)\n end\n\n # Use untyped if not types specified anywhere, otherwise try to\n # compute Parlour type given all these types\n if yard_types.empty?\n Logging.omit(\"no YARD type given for #{name.inspect}, using untyped\", reader || writer)\n parlour_type = Parlour::Types::Untyped.new\n elsif yard_types.all? { |x| x == 'nil' }\n # Nil attributes are extremely unusual, so just use untyped\n parlour_type = Parlour::Types::Untyped.new\n else\n parlour_type = TypeConverter.yard_to_parlour(\n yard_types, reader || writer, @type_converter_config)\n end\n\n # Generate attribute\n if reader && writer\n kind = :accessor\n elsif reader\n kind = :reader\n elsif writer\n kind = :writer\n end\n\n if @exclude_untyped && parlour_type.is_a?(Parlour::Types::Untyped)\n Logging.omit(\"excluding untyped attribute\", reader || writer, immediate: true)\n next\n end\n\n case @mode\n when :rbi\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n class_attribute: (attr_loc == :class)\n ) do |m|\n add_comments(reader || writer, m)\n end\n when :rbs\n if attr_loc == :class\n # RBS doesn't support class attr_accessors so create individual methods\n\n if reader\n @current_object.create_method(\n name.to_s,\n [Parlour::RbsGenerator::MethodSignature.new([], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(reader, m)\n end\n end\n\n if writer\n @current_object.create_method(\n \"#{name}=\",\n [Parlour::RbsGenerator::MethodSignature.new([Parlour::RbsGenerator::Parameter.new(\n \"value\",\n type: parlour_type,\n required: true\n )], parlour_type)],\n class_method: true\n ) do |m|\n add_comments(writer, m)\n end\n end\n else\n @current_object.create_attribute(\n name.to_s,\n kind: kind,\n type: parlour_type,\n ) do |m|\n add_comments(reader || writer, m)\n end\n end\n end\n end\n end\n end",
"def []=(attr_name, value)\r\n if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first\r\n attr_name = attr_name.split(ID_SEP)\r\n end\r\n\r\n if attr_name.is_a? Array\r\n value = value.split(ID_SEP) if value.is_a? String\r\n unless value.length == attr_name.length\r\n raise \"Number of attr_names and values do not match\"\r\n end\r\n #breakpoint\r\n [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}\r\n else\r\n write_attribute(attr_name, value)\r\n end\r\n end",
"def attr(symbol, writable=false) end",
"def define_writer!(k, definition)\n define_method(\"#{k}=\") do |value|\n # Recursively convert hash and array of hash to schematized objects\n value = ensure_schema value, definition[:schema]\n\n # Initial value\n instance_variable_set \"@#{k}\", value\n\n # Dirty tracking\n self.changed_attributes ||= Set.new\n self.changed_attributes << k\n end\n end",
"def validate\n validate_string_attributes\n end",
"def write_attribute_with_dynamo(field_name, value)\n if is_dynamo_field?(field_name)\n # Store these guys for now. We don't actually save the field value until the model is saved ( i.e my_supplier.save ).\n # If we were to save the field_value now we wouldn't be able to know the id of the model to link this value to it.\n # @see delay_save\n @all_fields_and_values ||= []\n @all_fields_and_values << {:dynamo_field=>cached_dynamo_field_by_name(field_name), :value=>value}\n end\n # If its a 'normal' attribute let rails write it in the usual way.\n write_attribute_without_dynamo(field_name, value)\n end",
"def define_attr_accessor(attr)\n attr_accessor(attr)\n end",
"def serialize(writer)\n raise StandardError, 'writer cannot be null' if writer.nil?\n writer.write_collection_of_object_values(\"attributeMappings\", @attribute_mappings)\n writer.write_boolean_value(\"enabled\", @enabled)\n writer.write_enum_value(\"flowTypes\", @flow_types)\n writer.write_collection_of_object_values(\"metadata\", @metadata)\n writer.write_string_value(\"name\", @name)\n writer.write_string_value(\"@odata.type\", @odata_type)\n writer.write_object_value(\"scope\", @scope)\n writer.write_string_value(\"sourceObjectName\", @source_object_name)\n writer.write_string_value(\"targetObjectName\", @target_object_name)\n writer.write_additional_data(@additional_data)\n end",
"def validate_attribute_syntax\n\t\t@values.each do |attribute, values|\n\t\t\t[ values ].flatten.each do |value|\n\t\t\t\tbegin\n\t\t\t\t\tself.get_converted_attribute( attribute.to_sym, value )\n\t\t\t\trescue => err\n\t\t\t\t\tself.log.error \"validation for %p failed: %s: %s\" %\n\t\t\t\t\t\t[ attribute, err.class.name, err.message ]\n\t\t\t\t\tattrtype = self.find_attribute_type( attribute )\n\t\t\t\t\tself.errors.add( attribute, \"isn't a valid %s value\" %\n\t\t\t\t\t\t[ attrtype.syntax ? attrtype.syntax.desc : attrtype.syntax_oid ] )\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\tend",
"def valid_attributes\n { }\n end",
"def validatable_attributes(atts, opts)\n am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)\n Array(atts).each do |a|\n next if am && !values.has_key?(a)\n v = send(a)\n next if an && v.nil?\n next if ab && v.respond_to?(:blank?) && v.blank?\n if message = yield(a, v, m)\n errors.add(a, message)\n end\n end\n end",
"def valid_attributes\n { }\n end",
"def valid_attributes\n { }\n end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def attribute_name=(_arg0); end",
"def require_attr(name)\n send(name).tap do |_|\n raise \"Attribute must be set: #{name}\" if _.nil?\n end\n end",
"def write_attributes(attributes)\n _attributes = attributes.select do |name, value|\n if self.is_dynamic_field?(name)\n self.dynamic_setter(name, value)\n false\n else\n true\n end\n end\n\n super(_attributes)\n end",
"def attribute; end",
"def attribute; end"
] |
[
"0.6472992",
"0.6315012",
"0.6315012",
"0.62821025",
"0.6279224",
"0.6211609",
"0.61891466",
"0.6182247",
"0.60683644",
"0.6032628",
"0.5995443",
"0.5988785",
"0.5959885",
"0.5938289",
"0.5931089",
"0.58951056",
"0.5859927",
"0.5851703",
"0.58493423",
"0.58465594",
"0.58328366",
"0.5823013",
"0.5822229",
"0.57850474",
"0.5701491",
"0.5696689",
"0.5682951",
"0.5678094",
"0.566814",
"0.5657499",
"0.56555206",
"0.5642589",
"0.56219065",
"0.5615893",
"0.56105876",
"0.559851",
"0.5598089",
"0.55940455",
"0.5585137",
"0.55848545",
"0.55796933",
"0.5571477",
"0.5567006",
"0.55667996",
"0.55652434",
"0.5562926",
"0.55600035",
"0.55590326",
"0.55590326",
"0.5554599",
"0.5554599",
"0.55407417",
"0.5534935",
"0.5527733",
"0.55271375",
"0.55238813",
"0.5501504",
"0.5497003",
"0.5496233",
"0.54927665",
"0.5464706",
"0.54617554",
"0.5461167",
"0.5451583",
"0.54498726",
"0.54498726",
"0.54359984",
"0.5430996",
"0.5430996",
"0.5426488",
"0.5418467",
"0.54153895",
"0.54107565",
"0.5407886",
"0.5401234",
"0.54008496",
"0.5400268",
"0.53910094",
"0.53827274",
"0.5377731",
"0.5375473",
"0.5374833",
"0.53720397",
"0.5370215",
"0.5363264",
"0.5361161",
"0.5360557",
"0.5351706",
"0.53514725",
"0.53492516",
"0.53459316",
"0.5341237",
"0.5328037",
"0.5328037",
"0.53230566",
"0.53230566",
"0.53230566",
"0.5319575",
"0.531832",
"0.5315559",
"0.5315559"
] |
0.0
|
-1
|
Checks equality by comparing each attribute.
|
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
id == o.id &&
title == o.title &&
image == o.image &&
image_type == o.image_type &&
servings == o.servings &&
ready_in_minutes == o.ready_in_minutes &&
license == o.license &&
source_name == o.source_name &&
source_url == o.source_url &&
spoonacular_source_url == o.spoonacular_source_url &&
aggregate_likes == o.aggregate_likes &&
health_score == o.health_score &&
spoonacular_score == o.spoonacular_score &&
price_per_serving == o.price_per_serving &&
analyzed_instructions == o.analyzed_instructions &&
cheap == o.cheap &&
credits_text == o.credits_text &&
cuisines == o.cuisines &&
dairy_free == o.dairy_free &&
diets == o.diets &&
gaps == o.gaps &&
gluten_free == o.gluten_free &&
instructions == o.instructions &&
ketogenic == o.ketogenic &&
low_fodmap == o.low_fodmap &&
occasions == o.occasions &&
sustainable == o.sustainable &&
vegan == o.vegan &&
vegetarian == o.vegetarian &&
very_healthy == o.very_healthy &&
very_popular == o.very_popular &&
whole30 == o.whole30 &&
weight_watcher_smart_points == o.weight_watcher_smart_points &&
dish_types == o.dish_types &&
extended_ingredients == o.extended_ingredients &&
summary == o.summary &&
wine_pairing == o.wine_pairing
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def ==(other)\n attributes == other.attributes\n end",
"def ==(other) # :nodoc:\n @attrs == other.attrs\n end",
"def eql?(other)\n return true if self == other\n @@ATTRIBUTES.each do |att|\n return false unless self.send(att).eql?(other.send(att))\n end\n true\n end",
"def assert_equal_attributes(object, expected_attributes)\n expected_attributes.each do |index, value|\n assert_equal value, object[index], \"#{index}\"\n end\n end",
"def attr_equal?(o)\n self == o and\n self.instance_variables_compare(o).empty? and\n self.attributes == o.attributes\n end",
"def same_attributes?(spec)\n @@attributes.all? {|name, default| self.send(name) == spec.send(name) }\n end",
"def ==(other)\n self.class.valid_attrs.each do |attr|\n return false if read(attr) != other.read(attr)\n end\n true\n end",
"def ==(other)\n self.attributes == (other.respond(:attributes) || {} )\n end",
"def ==(other)\n other.present? && self.attributes == other.attributes\n end",
"def ==(other)\n return false if other.nil? || !other.respond_to?(:attributes)\n attributes == other.attributes\n end",
"def match?(attributes)\n attributes.each do |attr, val|\n return false if send(attr).to_s != val.to_s\n end\n true\n end",
"def ==(other)\n self.class == other.class &&\n self.attributes == other.attributes\n end",
"def ==(other)\n self.class == other.class &&\n attributes == other.attributes\n end",
"def ==(other)\n return super unless other.is_a?(self.class)\n\n attributes.all? { |name, value| value == other.send(name) }\n end",
"def changed?(comparison)\n attributes.any? do |attribute, value|\n next unless comparison.key?(attribute)\n comparison[attribute] != value\n end\n end",
"def ==(other)\n return false unless self.class == other.class\n self.attributes == other.attributes\n end",
"def ==(other)\n if other.kind_of? Details::Attribute\n self.name == other.name && self.value == other.value\n else\n self.value == other\n end\n end",
"def ==(other)\n return false unless other.instance_of? self.class\n attributes == other.attributes\n end",
"def ==(other)\n return super unless other.is_a?(self.class)\n\n attributes.all? { |name, value| value == other.attributes[name] }\n end",
"def ==(other)\n return super unless other.is_a?(self.class)\n\n attributes.all? { |name, value| value == other.attributes[name] }\n end",
"def ==(other)\n return super unless other.is_a?(self.class)\n\n attributes.all? { |name, value| value == other.attributes[name] }\n end",
"def ==(other)\n Attribute === other && \n !(Expression === other) &&\n relation == other.relation && \n name == other.name && \n self.alias == other.alias && \n original_relation == other.original_relation\n end",
"def ==(obj)\n if obj.instance_of?(self.class)\n compare_attributes = [\"category_id\", \"combo_item_id\", \"quantity\", \"sequence\"]\n compare_attributes.each do |field|\n if self.send(field) != obj.send(field)\n return false\n end\n end\n return true\n end\n return false\n end",
"def ==(other)\n return false if other.class != self.class\n attr_hash == other.attr_hash\n end",
"def ==(other)\n case other\n when Chair::Row\n @attributes == other.instance_variable_get('@attributes')\n when Array\n @attributes.values == other\n else false\n end\n end",
"def == other\n return false unless other.kind_of? self.class\n attribute_of.all? do |key, val|\n val.get == other.__send__(key)\n end\n end",
"def correct_combination?(attr1, attr2, attr3)\n result = false\n if attr1 == attr2 && attr2 == attr3\n result = true\n elsif attr1 != attr2 && attr2 != attr3 && attr1 != attr3\n result = true\n end\n return result\n end",
"def ==(other)\n return false if self.class != other.class\n return super if @_lazer_model.required_properties.empty?\n @_lazer_model.required_properties.each do |key_name|\n return false if read_attribute(key_name) != other.read_attribute(key_name)\n end\n true\n end",
"def eql?(other)\n other.is_a?(self.class) && !self.class.comparison_attrs.find{|a| send(a) != other.send(a)}\n end",
"def verify_attributes(hash, expected)\n return [] unless expected.attributes\n expected.attributes.map{ |a| verify_attribute_value(hash[a.name.to_s], a) }\n end",
"def assert_attributes obj, attr_hash\n default_attr_hash = {}\n if obj.respond_to? :default_attr_hash\n default_attr_hash = obj.default_attr_hash\n end\n default_attr_hash.merge(attr_hash).each_pair do |key, value|\n assert_equal value, obj.__send__(key), \"Attribute #{key} of #{obj}\"\n end\n end",
"def match_attributes(attrs)\n attrs = Saxxy::Helpers.stringify_keys(attrs)\n attributes.reduce(true) do |b, (k, v)|\n value = attrs[k]\n b && ((!value.nil? && match(v, value)) || (v.nil? && value.nil?))\n end\n end",
"def equal_set(expected)\n message = \"#{Helpers.inspect_records(@object)} has the same records as #{Helpers.inspect_records(expected)}\"\n \n left = @object.map(&:id).sort\n right = expected.map(&:id).sort\n \n test_case.assert(left != right, message)\n end",
"def ===(other)\n required = self.class.required_attributes\n\n other.respond_to?(:keys) && (common = other.keys & required) &&\n common.size == other.keys.size && common.size == required.size\n end",
"def bt_same_value?(other)\n bt_value_attributes == other.bt_value_attributes\n end",
"def ==(x)\n return true if object_id == x.object_id\n return false unless x.kind_of?(AttrArray)\n each_with_index do |a, n|\n return false unless a == x[n]\n end\n true\n end",
"def equal_set(expected)\n message = \"#{Helpers.inspect_records(@object)} does not have the same records as #{Helpers.inspect_records(expected)}\"\n \n left = @object.map(&:id).sort\n right = expected.map(&:id).sort\n \n test_case.assert(left == right, message)\n end",
"def compare_attributes(data_criteria, criteria)\n return false unless data_criteria['dataElementAttributes']&.any?\n\n data_criteria['dataElementAttributes'].map { |dc| dc.except('_id') }.include? criteria['dataElementAttributes'][attribute_index].except('_id')\n end",
"def ==(other)\n @klass == other.class && @attributes == strip_active_record(other)\n end",
"def ==(other)\n other.is_a?(self.class) &&\n other.attribute == attribute &&\n other.validation == validation &&\n other.expected == expected &&\n other.actual == actual\n end",
"def == other\n return false unless self.class == other.class\n [:unit, :frequency, :anchor, :weeks, :monthdays, :weekdays, :times].all? do |attribute|\n self.send(attribute) == other.send(attribute)\n end\n end",
"def compare_equal?(item, line_item)\n ![\n :ax_account_number,\n :ax_account_id,\n :ax_order_number,\n :ax_order_id,\n :email_address,\n :first_name,\n :last_name,\n :serial_number,\n :purch_order_form_num\n ].detect { |attr| item.send(attr) != line_item.send(attr) }\n end",
"def ==(b) # :nodoc:\n ( b.respond_to?(:result_attributes) &&\n result_attributes == b.result_attributes && \n @result_attributes.all?{ |k| send(k) == b.send(k) } )\n end",
"def validates_different(*attr_names)\n validates_with ValidatesAll::DifferenceValidator, _merge_attributes(attr_names)\n end",
"def identical?\n #Song.first.attributes.each { |v,k| Song.find(:all, :conditions => [\" #{v} like ?\", \"%blah%\"])}\n Song.find(:all, :conditions => [\"name = ? or length = ?\", \"#{self.name}\", self.length]) do |x| \n x.hash == self.hash\n end\n end",
"def diff?(model = self.class.find(id))\n self.class.diffable_attributes.each do |attribute|\n return true if send(attribute) != model.send(attribute)\n end\n return false\n end",
"def filter_attributes_match?(hash_one, hash_two)\n hash_one.all? do |key, value_one|\n value_two = hash_two[key]\n case\n when value_one == value_two\n true\n when value_one.is_a?(Hash) && value_two.is_a?(Hash)\n filter_attributes_match?(value_one, value_two)\n when hash_one[key].to_s == hash_two[key].to_s\n true\n when value_one.is_a?(String) && value_one.start_with?(\"eval:\")\n eval_attribute_value(value_one, value_two)\n else\n false\n end\n end\n end",
"def comparable_attributes\n#\t\tHashWithIndifferentAccess[attributes.select {|k,v| \n#\t\t\t!Abstract.incomparable_attribute_names.include?(k)}]\n\t\tHashWithIndifferentAccess[attributes.select {|k,v| db_fields.include?(k)}]\n\tend",
"def all_equal?\n a = self.first\n all? { |b| a == b }\n end",
"def check_attrs(attr_list)\r\n attrs = []\r\n attr_list.each do |attr_sym|\r\n attr = assigns(attr_sym.to_sym)\r\n assert_not_nil attr, \"Attribute @#{attr_sym} should not be nil\"\r\n assert !attr.new_record?, \"Should have saved the @#{attr_sym} obj\" if attr.class == ActiveRecord\r\n attrs << attr\r\n end\r\n attrs.length > 1 ? attrs : attrs[0]\r\n end",
"def check_attrs(attr_list)\r\n attrs = []\r\n attr_list.each do |attr_sym|\r\n attr = assigns(attr_sym.to_sym)\r\n assert_not_nil attr, \"Attribute @#{attr_sym} should not be nil\"\r\n assert !attr.new_record?, \"Should have saved the @#{attr_sym} obj\" if attr.class == ActiveRecord\r\n attrs << attr\r\n end\r\n attrs.length > 1 ? attrs : attrs[0]\r\n end",
"def attr_set?(cards, attr)\n array = []\n cards.each do |card|\n # evalutes the string 'attr' and returns the value\n array << card.send(attr)\n end\n\n # only return true if it's all the same or totally different\n return true if array.uniq.count == 1\n return true if array.uniq.count == 3\n return false\n end",
"def attribute_changed?(attribute_name)\n (self.diff['attributes']['new']||{})[attribute] != (self.diff['attributes']['old']||{})[attribute]\n end",
"def eql?(other)\n return false if (other.nil? or self.class != other.class)\n return false unless super(other)\n return false unless self.attributes == other.attributes\n return false unless self.nodes == other.nodes\n true\n end",
"def eql?(other)\n return false unless self.class == other.class\n self.key_attributes == other.key_attributes\n end",
"def uniquify_attributes(attributes)\n attributes.each do |ka|\n oldval = send(ka)\n next unless String === oldval\n newval = UniquifierCache.instance.get(self, oldval)\n set_property_value(ka, newval)\n logger.debug { \"Reset #{qp} #{ka} from #{oldval} to unique value #{newval}.\" }\n end\n end",
"def eql?(object)\n self.class.equal?(object.class) && attributes == object.attributes\n end",
"def multi_element_attr_check( elements )\n wanted = Array.new\n found = Array.new\n elements.each do |element|\n print \".\"\n e = $driver.find_element(element[0].to_sym, element[1])\n wanted << [ element[1], element[2], element[3] ]\n found << [ element[1], element[2], e.attribute(element[2]) ]\n end\n\n found.should == wanted\n end",
"def equals(rule)\n element == rule.element && attributes == rule.attributes\n end",
"def attr_reader(*args)\n super\n comparison_attrs.concat(args)\n end",
"def xml_nodes_match_attrs(xml_nodes, attrs, mismatches = [])\n attrs.each_with_index.each { |attr_set, idx|\n xn = xml_nodes[idx]\n attr_set.each { |(attr_key, attr_val)|\n # Either call method, or hash key, or recurse on children\n # p.name vs. p[:name]\n if :children == attr_key\n # recurse over children\n xml_nodes_match_attrs(xn.children, attr_val, mismatches)\n else\n # compare attrs\n xn_val = xn.methods.include?(attr_key) ? xn.send(attr_key) : xn[attr_key]\n if xn_val != attr_val\n mismatches << { node: xn.name_and_class_path, attr: \"#{ attr_key }: expected #{ attr_val.inspect }, got #{ xn_val.inspect }\" }\n end\n end\n }\n }\n mismatches\n end",
"def matches_state_attrs?\n @expected_attrs == state_attrs\n end",
"def equal_list(expected)\n message = \"#{Helpers.inspect_records(@object)} has the same records as #{Helpers.inspect_records(expected)}\"\n \n left = @object.map(&:id)\n right = expected.map(&:id)\n \n test_case.assert(left != right, message)\n end",
"def eql?(other)\n return false unless super(other)\n return false unless attributes == other.attributes\n return false unless content == other.content\n\n true\n end",
"def ==(other)\n return true if other.equal?(self)\n return false unless other.instance_of?(self.class)\n\n self.class.attributes.inject(true) do |memo, attribute|\n attribute_name = attribute.first\n attribute_type = attribute.last[:type]\n\n # Skip associations\n if attribute_type.include?(LazyResource::Resource) || (attribute_type.is_a?(::Array) && attribute_type.first.include?(LazyResource::Resource))\n memo\n else\n memo && self.send(:\"#{attribute_name}\") == other.send(:\"#{attribute_name}\")\n end\n end\n end",
"def matches? item, attributes\n\n attributes.map { |attribute, value|\n\n item.send(attribute) == value\n\n }.flatten == [true]\n\n end",
"def ==( other ) \n\t\t\tcomparison_attributes = lambda{ |area| [ area.area_desc, area.altitude, area.ceiling, area.circles, area.geocodes, area.polygons ]}\n\t\t\tcomparison_attributes.call( self ) == comparison_attributes.call( other )\n\t\tend",
"def all_obs_same_attr?(observations, attr)\n exemplar = observations.first.send(attr)\n observations.all? { |o| o.send(attr) == exemplar }\n end",
"def eql?(*) end",
"def eql?(other)\n return true if equal?(other)\n return false unless self == other\n [:id, :fide_id, :rating, :fide_rating, :title, :gender].each do |m|\n return false if self.send(m) && other.send(m) && self.send(m) != other.send(m)\n end\n true\n end",
"def match\n @matches = attributes_enumerator.map do |(type, value), index|\n attribute_name = self.class.names[index]\n attributes.store(\n attribute_name, type.match(value, context: @context.dup)\n )\n end\n return if (failures = @matches.select(&:invalid?)).empty?\n failures.unshift(failure).reduce(:merge!)\n end",
"def ==(val)\n if val.is_a?(Model)\n # Use normal comparison for a model\n super\n else\n # Compare to attributes otherwise\n attributes == val\n end\n end",
"def ==(o)\n return true if self.equal?(o)\n self.class == o.class &&\n attribute == o.attribute &&\n statistics == o.statistics &&\n other == o.other &&\n total == o.total &&\n missing == o.missing &&\n term_count == o.term_count &&\n term_type == o.term_type &&\n terms == o.terms\n end",
"def ==(*several_variants)\n #This is a stub, used for indexing\n end",
"def is_equal?(a)\n @amount == a.amount && @code == a.code\n end",
"def equal_list(expected)\n message = \"#{Helpers.inspect_records(@object)} does not have the same records as #{Helpers.inspect_records(expected)}\"\n \n left = @object.map(&:id)\n right = expected.map(&:id)\n \n test_case.assert(left == right, message)\n end",
"def comparison_attributes\n except_list = ['id', 'updated_at', 'created_at', 'verified_at']\n except_list << 'alternative_phone' unless Spree::Config[:alternative_shipping_phone]\n except_list << 'company' unless Spree::Config[:company]\n\n a = attributes.except(*except_list)\n a.each{|k, v|\n if v.is_a?(String)\n v = v.downcase.strip.gsub(/\\s+/, ' ')\n a[k] = v.present? ? v : nil\n end\n }\n a['state_name'] = nil if a['state_name'].blank?\n a\n end",
"def multi_element_attr_match( elements )\n elements.each do |element|\n print \".\"\n wait_for_element(element[0].to_sym, element[1])\n check_attribute_match(element[0].to_sym, element[1], element[2], element[3])\n end\n end",
"def xml_should_eql(actual, expected)\n same = xml_cmp(actual, expected)\n actual.should.== expected unless same \nend",
"def test_equality_simple\n value1_ = ::Versionomy.create(:major => 2, :minor => 0, :release_type => :alpha, :alpha_version => 5)\n value2_ = ::Versionomy.create(:major => 2, :release_type => :alpha, :alpha_version => 5)\n assert_equal(value2_, value1_)\n assert_equal(value2_.hash, value1_.hash)\n end",
"def ==(other)\n other.is_a?(self.class) &&\n name == other.name &&\n attributes == other.attributes\n end",
"def changes(attrs1, attrs2)\n old_attrs = attrs1.slice(*GENERATED_ATTRS)\n new_attrs = attrs2.slice(*GENERATED_ATTRS)\n\n return if old_attrs == new_attrs\n old_attrs.each do |k, v|\n next if new_attrs[k] == v\n @changes << Change.new(nil, k, v, new_attrs[k]) \n end\n end",
"def tdiff_equal(node)\n if (self.class == node.class)\n case node\n when Nokogiri::XML::Attr\n (self.name == node.name && self.value == node.value)\n when Nokogiri::XML::Element, Nokogiri::XML::DTD\n self.name == node.name\n when Nokogiri::XML::Text, Nokogiri::XML::Comment\n self.text == node.text\n when Nokogiri::XML::ProcessingInstruction\n (self.name == node.name && self.content = self.content)\n else\n false\n end\n else\n false\n end\n end",
"def ==(other)\n name == other.name &&\n color == other.color &&\n age == other.age\n end",
"def more_desirable?(attribute_id1, attribute_id2)\n attribute_id1 < attribute_id2\n end",
"def isSame(tab)\n for x in 0..3\n for y in 0..3\n return(false) if (self.val(x,y) != tab.val(x,y)) ;\n end\n end\n return true ;\n end",
"def ==(other)\n # If the classes don't match, they cannot possibly be equal.\n if self.class != other.class\n return false\n end\n\n # If the persisted state doesn't match, they also can never be equal.\n if persisted? != other.persisted?\n return false\n end\n\n # When persisted, check the other's id to see if it's the same,\n # cannot possible be equals if they have different ids.\n if persisted? && id != other.id\n return false\n end\n\n # Finally, compare the attributes hash. If all key/values match,\n # they are considered equal.\n attributes == other.attributes\n end",
"def ==(other)\n self.class == other.class &&\n attributes[\"_id\"] == other.attributes[\"_id\"]\n end",
"def assert_same_values(expected, actual)\n actual.each_pair do |k,v|\n next unless expected[k]\n assert_equal expected[k], v, \"Values for #{k} are not matching\"\n end\n end",
"def assert_equivalent_xml(expected, actual)\n expected_xml = Nokogiri::XML(\"<test-xml>\\n#{expected}\\n</test-xml>\")\n actual_xml = Nokogiri::XML(\"<test-xml>\\n#{actual}\\n</test-xml>\")\n ignored_attributes = %w(style data-disable-with)\n\n equivalent = EquivalentXml.equivalent?(expected_xml, actual_xml, {\n ignore_attr_values: ignored_attributes\n }) do |a, b, result|\n if result === false && b.is_a?(Nokogiri::XML::Element)\n if b.attr('name') == 'utf8'\n # Handle wrapped utf8 hidden field for Rails 4.2+\n result = EquivalentXml.equivalent?(a.child, b)\n end\n if b.delete('data-disable-with')\n # Remove data-disable-with for Rails 5+\n # Workaround because ignoring in EquivalentXml doesn't work\n result = EquivalentXml.equivalent?(a, b)\n end\n if a.attr('type') == 'datetime' && b.attr('type') == 'datetime-local'\n a.delete('type')\n b.delete('type')\n # Handle new datetime type for Rails 5+\n result = EquivalentXml.equivalent?(a, b)\n end\n end\n result\n end\n\n assert equivalent, lambda {\n # using a lambda because diffing is expensive\n Diffy::Diff.new(\n sort_attributes(expected_xml.root),\n sort_attributes(actual_xml.root)\n ).to_s(:color)\n }\n end",
"def sync_duplicate_obj_attributes(obj1, obj2)\n duplicate_keys.each do |key|\n unless obj1[key].blank? && obj2[key].blank?\n if obj1[key].blank?\n obj1.send(\"#{key}=\", obj2[key])\n elsif obj2[key].blank?\n obj2.send(\"#{key}=\", obj1[key])\n else # Each obj has a value\n if obj1[key] != obj2[key]\n raise ArgumentError, \"#{key} attribute values on the two objects don't match: #{obj1[key]} vs #{obj2[key]}\"\n end\n end\n end\n end\n end",
"def eql?(other)\n return true if equal?(other)\n\n # two instances for different models cannot be equivalent\n return false unless other.kind_of?(model)\n\n # two instances with different keys cannot be equivalent\n return false if key != other.key\n\n # neither object has changed since loaded, so they are equivalent\n return true if repository == other.repository && !dirty? && !other.dirty?\n\n # get all the loaded and non-loaded properties that are not keys,\n # since the key comparison was performed earlier\n loaded, not_loaded = properties.select { |p| !p.key? }.partition do |property|\n attribute_loaded?(property.name) && other.attribute_loaded?(property.name)\n end\n\n # check all loaded properties, and then all unloaded properties\n (loaded + not_loaded).all? { |p| p.get(self) == p.get(other) }\n end",
"def assert_event_are_light_equal e1, e2\n return false if e1.class != e2.class\n\n [:subject, :event, :moodid,\n :mood, :music, :location, :taglist, :pickeyword,\n :preformatted, :backdated, :comments, :security, :allowmask,\n :screening,].each do |attr|\n return false if e1.send(attr) != e2.send(attr)\n end\n\n e1.compare_time(e2)\n end",
"def eql(expected)\n set_relativity(:eql, expected)\n end",
"def modified?( original )\n DATA_ATTRIBUTES.any? { |e| send( e ) != original.send( e )}\n end",
"def ==(other)\n @name == other.name && @amount == other.amount\n end",
"def ==(other)\n other.kind_of?(self.class) &&\n @name == other.name && @columns == other.columns && @unique == other.unique?\n end",
"def match_same_name_attributes(*options)\n\n options = options.extract_options!\n same_name_attributes = @from_table.columns.map(&:name) & @to_table.columns.map(&:name)\n\n if same_name_attributes\n same_name_attributes = columns_from_options(same_name_attributes, options)\n same_name_attributes.each do |same_name_attribute|\n from same_name_attribute, :to => same_name_attribute\n end\n end\n end",
"def equal_pair(key, request)\n if @event[\"required\"][key] == request[\"object_attributes\"][key] || event[\"required\"][key] == \"\"\n true\n else\n false\n end\n end",
"def assert_equal(att, value, error = [att, :not_equal])\n assert value === send(att), error\n end",
"def validate\n matched = {}\n duplicated_attributes = []\n attributes.each do |attribute|\n if matched.has_key?(attribute.name) && matched[attribute.name] == attribute.name_format\n duplicated_attributes << attribute.name unless duplicated_attributes.include?(attribute.name)\n else\n matched[attribute.name] = attribute.name_format\n end\n end\n if !duplicated_attributes.empty?\n raise ValidationError, \"An attribute with the same name and name format may only be specified once. The following attributes were specified multiple times: #{duplicated_attributes.join(',')}\"\n end\n end"
] |
[
"0.7291717",
"0.7188103",
"0.70395297",
"0.7007927",
"0.68874705",
"0.6861532",
"0.6707156",
"0.6660597",
"0.66147524",
"0.658478",
"0.6584619",
"0.6580019",
"0.65543133",
"0.6543933",
"0.65068495",
"0.6479513",
"0.6456241",
"0.6415999",
"0.6412208",
"0.6412208",
"0.6412208",
"0.6411266",
"0.6380575",
"0.63775986",
"0.6260147",
"0.6246534",
"0.6240681",
"0.62150854",
"0.62014365",
"0.6186426",
"0.61837834",
"0.6164858",
"0.61304426",
"0.61149454",
"0.6097789",
"0.6083095",
"0.6078927",
"0.6067201",
"0.60053444",
"0.59974694",
"0.5994989",
"0.5991373",
"0.59856457",
"0.5985243",
"0.5977118",
"0.59521115",
"0.59428704",
"0.59311265",
"0.59247756",
"0.5921222",
"0.5921222",
"0.59095234",
"0.58795947",
"0.58789194",
"0.5870439",
"0.58598673",
"0.58571184",
"0.5856412",
"0.5855177",
"0.58480394",
"0.5847516",
"0.58370507",
"0.5799985",
"0.5795313",
"0.57880926",
"0.57823527",
"0.57788265",
"0.5776185",
"0.57670164",
"0.5759791",
"0.5758563",
"0.5753949",
"0.57518554",
"0.5750137",
"0.57385117",
"0.57309806",
"0.5729126",
"0.572618",
"0.57250285",
"0.57210624",
"0.5712646",
"0.5710082",
"0.57059866",
"0.57036847",
"0.5702592",
"0.5690256",
"0.5674193",
"0.56433815",
"0.5641553",
"0.56216776",
"0.56148046",
"0.5591313",
"0.5587681",
"0.55836356",
"0.5569298",
"0.5550885",
"0.5546161",
"0.5545665",
"0.55422115",
"0.5539372",
"0.5529004"
] |
0.0
|
-1
|
Calculates hash code according to all attributes.
|
def hash
[id, title, image, image_type, servings, ready_in_minutes, license, source_name, source_url, spoonacular_source_url, aggregate_likes, health_score, spoonacular_score, price_per_serving, analyzed_instructions, cheap, credits_text, cuisines, dairy_free, diets, gaps, gluten_free, instructions, ketogenic, low_fodmap, occasions, sustainable, vegan, vegetarian, very_healthy, very_popular, whole30, weight_watcher_smart_points, dish_types, extended_ingredients, summary, wine_pairing].hash
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def attr_hash\n Digest::MD5.hexdigest(\"#{@name}:#{@ruby_type}\")\n end",
"def hash() end",
"def hash() end",
"def hash() end",
"def hash() end",
"def hash() end",
"def hash() end",
"def hash() end",
"def hash\n code = 17\n code = 37*code + @x.hash\n code = 37*code + @y.hash\n # Add lines like this for each significant instance variable\n code # Return the resulting code\n end",
"def hash(*) end",
"def hash\n code = 17\n code = 37 * code\n self.instance_variables.each do |v|\n code += self.instance_variable_get(v).hash\n end\n code\n end",
"def hash_code; end",
"def calculate_hash!\n prefix = PREFIX_NAME_LOOKUP[self.type]\n # add special cases for refs\n self.hash_id = NodeId.sha1(\"#{prefix} #{self.size}\\0#{self.content}\")\n end",
"def hash() #:nodoc:\n prime = 31;\n result = 1;\n result = prime * result + @amount.to_i\n result = prime * result + @new_balance.to_i\n result = prime * result + (@date.nil? ? 0 : Bankjob.date_time_to_ofx(@date).hash);\n result = prime * result + (@raw_description.nil? ? 0 : @raw_description.hash);\n result = prime * result + (@type.nil? ? 0 : @type.hash);\n # don't use value date\n return result;\n end",
"def hash\n prime = 31\n result = 1\n result = result * prime + (@decision_target == nil ? 0 : @decision_target.hash)\n result = prime * result + (@string_id == nil ? 0 : @string_id.hash)\n result\n end",
"def hash\n @hash ||= begin\n result = 17\n result = 31 * result + self.class.hash\n result = 31 * result + ord\n result.is_a?(Fixnum) ? result : result.hash\n end\n end",
"def hash\n @hash ||= begin\n result = 17\n result = 31 * result + self.class.hash\n result = 31 * result + ord\n result.is_a?(Fixnum) ? result : result.hash\n end\n end",
"def hash; map{|el| \"#{el.name} @ #{el.hash}\"}; map(&:hash).reduce(:+) % 2**32; end",
"def hash\r\n a = 0\r\n @id.each_byte {|c| a += c.to_i}\r\n (a + @paired.to_i) * HASH_PRIME\r\n end",
"def hash\n raw = [name, type, values.join('/')].join(' ')\n Digest::MD5.hexdigest(raw)\n end",
"def hash\n size.hash ^ rank.hash\n end",
"def hash\n \"#{self.class.name}-#{self.id}-#{@__metadata__.cas}-#{@__attributes__.hash}\".hash\n end",
"def hash\n @hash || calculate_hash!\n end",
"def hash\n return name.hash ^ direction.hash ^ lhs.hash ^ rhs.hash\n end",
"def hash\n value = 0\n my_rows = @rows\n r_size = my_rows.size\n for i in 0..r_size-1 do\n a_row = my_rows[i]\n a_size = a_row.size\n for j in 0..a_size-1 do\n value ^= a_row[j].hash\n end\n end\n return value\n end",
"def hash\n id.hash + 32 * bs_request.hash\n end",
"def do_hash(input)\n a = OpenSSL::Digest.hexdigest(\"SHA224\", input).to_i % 19\n b = OpenSSL::Digest.hexdigest(\"SHA512\", input).to_i % 19\n [a, b]\n end",
"def hash\n type.hash ^ (id.hash >> 1)\n end",
"def hash\n [self.class, self.val, self.attribute].hash\n end",
"def hash # :nodoc:\n identifier.hash ^ requirement.hash\n end",
"def hash\n 0\n end",
"def hash\n self.class.hash ^ key_attributes.hash\n end",
"def hash\n return super unless has_size?\n\n res = 0\n each do |el|\n res += el.hash\n end\n return res\n end",
"def hash\n h = @e.nil? ? 0 : @e\n h = (h << 1) ^ @r.hash\n h = (h << 1) ^ @v.hash\n end",
"def hash() source.hash ^ (target.hash+1); end",
"def hash() source.hash ^ (target.hash+1); end",
"def hash\n\t\t\"#{@x}#{@y}\".hash\n\tend",
"def hash #:nodoc:\n __getobj__.hash ^ self.class.hash\n end",
"def hash\n Zlib.crc32(to_a.map(&:to_s).sort.to_s)\n end",
"def hash_code\n prime = 31\n result = 1\n result = prime * result + x\n result = prime * result + y\n return result;\n end",
"def hash\n self.class.hash ^ operand.hash\n end",
"def hash\n ([self.class] + self.class.comparison_attrs.map{|x| send(x)}).hash\n end",
"def hash\n [anchor, cv, nullifier, proof, rk, spend_auth_sig].hash\n end",
"def hash!\n\t\t@@email.downcase!\n\t\thash = Digest::MD5.hexdigest(@@email)\n\t\treturn hash\n\tend",
"def hash\n @symbols.hash + 37*positive?.hash\n end",
"def calculate_unique_hash\n unique = ''\n unique += self.content if self.content.present?\n unique += self.summary if self.summary.present?\n unique += self.title if self.title.present?\n self.unique_hash = Digest::MD5.hexdigest unique\n end",
"def hash()\n #This is a stub, used for indexing\n end",
"def hash\n # Memoizing such a simple hash value seems silly, however the\n # profiler showed the Card#hash method as having 22% of the runtime. My\n # memoizing the hash value that was reduced to 12%.\n return @hash unless @hash.nil?\n @hash = @value.hash ^ @suit.hash\n end",
"def hash=(_arg0); end",
"def block_hash\n\t\tdigest = Digest::SHA2.new\n\n\t\tdigest << '%d' % [ self.index ]\n\t\tdigest << self.timestamp.strftime( '%s%N' )\n\t\tdigest << self.payload\n\t\tdigest << self.payload_hash\n\t\tdigest << self.proof.to_s\n\t\tdigest << self.previous_hash\n\t\t\n\t\treturn digest.hexdigest\n\tend",
"def hash\n num = 0\n self.each do |k,v|\n if k.is_a?(Integer) && v.is_a?(Integer)\n num += k * 26 + v\n elsif k.is_a?(Integer) && !v.is_a?(Integer)\n num += k * 26 + ALPHA_NUMBERS[v.to_s.downcase]\n elsif v.is_a?(Integer) && !k.is_a?(Integer)\n num += v * 26 + ALPHA_NUMBERS[k.to_s.downcase]\n elsif !k.nil? && !v.nil?\n num += ALPHA_NUMBERS[k.to_s.downcase] * ALPHA_NUMBERS[v.to_s.downcase]\n end\n end\n num\n end",
"def hash\r\n\t\treturn @name.hash() + @type.hash()\r\n\tend",
"def hash\n return @hash_code if defined? @hash_code\n @hash_code = usual_equal_object.hash\n end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash\n [oct, pc].hash\n end",
"def hash\n excl = @excl ? 1 : 0\n hash = excl\n hash ^= @begin.hash << 1\n hash ^= @end.hash << 9\n hash ^= excl << 24;\n # Are we throwing away too much here for a good hash value distribution?\n return hash & Fixnum::MAX\n end",
"def hash\n code.hash\n end",
"def hash # :nodoc:\n name.hash ^ type.hash ^ requirement.hash\n end",
"def hash\n @vbits.hash\n end",
"def hash\n Digest::SHA256.hexdigest( \"#{nonce}#{time}#{difficulty}#{prev}#{data}\" )\n end",
"def hash\n if @sha512hash != nil\n return @sha512hash.to_i(16)\n else\n super\n end\n end",
"def hash\n [lac, cid, radio, mcc, mnc, signal, psc, asu, ta].hash\n end",
"def calc_hash(pass)\n salt_cost = SCrypt::Engine.autodetect_cost(self[:salt])\n SCrypt::Engine.scrypt(pass, self[:salt], salt_cost, 32).unpack('H*').first\n end",
"def calculate_checksum\n last_checksum = previous_event&.checksum\n attrs = attributes.except(\"checksum\", \"id\", \"updated_at\").merge(last_checksum: last_checksum)\n cs = Digest::SHA256.hexdigest(attrs.to_s)\n puts \"#{id} calculate_checksum: #{cs} <- #{attrs} \" if Rails.env.development?\n Rails.logger.info(\"#{id} calculate_checksum: #{cs} <- #{attrs} \")\n return cs\n end",
"def hash\n code.hash\n end",
"def hash\n\t\t[@a, @b, self.class::D].hash\n\tend",
"def consistent_hash\n Zlib.crc32(self.to_yaml, 0)\n end",
"def hash\n @hash[:perm_type].hash ^\n @hash[:perms].hash ^\n @hash[:inheritance].hash ^\n @hash[:target].hash\n end",
"def hash( *strs )\n return Digest::MD5.hexdigest( strs.join )\n end",
"def hash\n @rank.hash ^ @suit.hash\n end",
"def hash\n return Digest::MD5.hexdigest(self.describe(' '))\n end",
"def hash\n @real.hash ^ @image.hash\n end",
"def to_hash() end",
"def hash_length\n super\n end",
"def hash\n [first_name, last_name, address_one, address_two, city, state, zip, phone, email, country_code].hash\n end",
"def hash_hash(h)\n require 'digest/md5'\n Digest::MD5.hexdigest(Marshal::dump(h.sort))\n end",
"def hash() source.hash ^ target.hash; end",
"def calculate_hash(input, prep_hashes)\n result = 0\n input.unpack('U*').each do |x|\n result += prep_hashes.hash(x)\n end\n (result % MOD_VALUE).to_s(HEX)\nend",
"def c_hash\n sha256 = Digest::SHA256.new\n token = @code.token.token\n hashed_token = sha256.digest(token)\n first_half = hashed_token[0...hashed_token.length / 2]\n Base64.urlsafe_encode64(first_half).tr('=', '')\n end",
"def hash(block)\n Digest::SHA256.hexdigest(block.to_s.encode)\n end",
"def calculate_hash\n\t\toptions = {:firstname => firstname, :email => email, :phone => phone, :txnid => txnid, :surl => surl, :furl => furl, :productinfo => productinfo, :amount => amount}\n\t\tservice = PayuIndia::Helper.new(payment_gateway_key, payment_gateway_salt, options)\n\t\tself.hast = service.generate_checksum\n\tend",
"def hash\n [rank, suit].hash\n end",
"def hash\n self.class.hash ^ left.hash ^ right.hash\n end",
"def hashify_attributes(attrs)\n Hash.new.tap{ |h| attrs.each{|a| h[a] = self.send(a)} }\n end",
"def generate_hash(*args)\n Digest::SHA3.hexdigest(args.join(''))\n end",
"def hash_code\n hash_code = {}\n self.seq.each do |letter|\n hash_code.keys.include?(letter) ? hash_code[letter] += 1 : hash_code[letter] = 1\n end\n hash_code\n end",
"def hash\n attributes.hash\n end",
"def hash\n attributes.hash\n end",
"def hash\n attributes.hash\n end",
"def hash\n\n self.h.fei.hash\n end",
"def hash\n shasum.hash\n end",
"def hash\n shasum.hash\n end"
] |
[
"0.7121255",
"0.7037823",
"0.7037823",
"0.7037823",
"0.7037823",
"0.7037823",
"0.7037823",
"0.7037823",
"0.68942124",
"0.6782416",
"0.6706031",
"0.66977906",
"0.66866964",
"0.6668208",
"0.6487407",
"0.6460204",
"0.6460204",
"0.64430994",
"0.64097935",
"0.63958734",
"0.6387996",
"0.63748425",
"0.6355284",
"0.63357705",
"0.62658477",
"0.625267",
"0.62436604",
"0.6229914",
"0.62206197",
"0.62137693",
"0.6211102",
"0.61990553",
"0.6190204",
"0.6184779",
"0.6181884",
"0.6181884",
"0.6152481",
"0.6145122",
"0.61412936",
"0.61345357",
"0.6128005",
"0.61237264",
"0.6121597",
"0.612048",
"0.61008084",
"0.6100038",
"0.6092384",
"0.60912204",
"0.60804003",
"0.60787517",
"0.60470223",
"0.6032663",
"0.60207",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.6018572",
"0.60158443",
"0.6012482",
"0.5994702",
"0.5988974",
"0.5985988",
"0.5977637",
"0.5970418",
"0.5969655",
"0.5966839",
"0.59586835",
"0.5954397",
"0.5941761",
"0.59406847",
"0.5924587",
"0.59219056",
"0.5902945",
"0.5902466",
"0.58512187",
"0.58467513",
"0.5845265",
"0.5844118",
"0.58435136",
"0.5841671",
"0.5838006",
"0.58370525",
"0.5835755",
"0.5824722",
"0.582271",
"0.58220696",
"0.58175004",
"0.5817197",
"0.5811783",
"0.5810246",
"0.5810246",
"0.5810246",
"0.5809122",
"0.5806307",
"0.5806307"
] |
0.0
|
-1
|
Builds the object from hash
|
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
attributes = attributes.transform_keys(&:to_sym)
self.class.openapi_types.each_pair do |key, type|
if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
self.send("#{key}=", nil)
elsif type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end
end
self
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def build(hash)\n obj = new\n hash.each_pair do |k,v|\n obj[k] = v if variables[k]\n end\n return obj\n end",
"def build_from_hash(attributes)\n\n end",
"def build_from_hash(hash)\n instance = self.new\n\n # Add the instance attributes dynamically from the hash. If the attribute\n # does not already exist, then don't re-add the attribute class and\n # variable, just set it with the value from the hash\n hash.keys.each do |key|\n class_eval { attr_accessor key } unless instance.methods.include?(key.to_sym)\n instance.instance_variable_set \"@#{key}\", hash[key]\n end\n\n instance\n end",
"def build(hash, track_changes = true)\n resource = fields.each_with_object(new) do |field, r|\n value = hash.fetch(field.to_s, hash[field.to_sym])\n r.send(\"#{field}=\", value)\n end\n resource.clear_changes! unless track_changes\n resource\n end",
"def initialize hash\n @hash = hash\n end",
"def build(params)\n return new(params) if params.is_a?(Hash)\n raise(\"unexpected parameter, expected Hash, received #{params.class}\")\n end",
"def initialize( hash )\n\t\t\t@hash = hash.dup\n\t\t\t@dirty = false\n\t\tend",
"def initialize(a_hash)\n from_h(a_hash)\n end",
"def initialize\n\t\t\t@hash = {}\n\t\tend",
"def initialize(hash)\n @hash = hash\n @converted = {}\n end",
"def initialize(hash)\n @short_code = hash[\"short_code\"]\n @name = hash[\"name\"]\n @id = hash[\"id\"]\n end",
"def initialize(hash)\n super(hash)\n end",
"def initialize\n @h = new_hash\n end",
"def new_from_hash(hash)\n if hash == nil\n self.class.new.assign(self)\n else\n hash_obj = hash\n if hash.instance_of?(Hash)\n hash_obj = self.class.new\n merge_hash_into_object(hash, hash_obj)\n end\n instance = self.class.new\n object_assign(instance, hash_obj)\n end\n end",
"def initialize(hash={})\n @hash = hash\n end",
"def initialize\n @hash = {}\n end",
"def initialize\n @hash = {}\n end",
"def initialize(hash)\r\n hash.each { |k, v|\r\n # Create getters and setters\r\n self.class.attr_accessor(k)\r\n # Set value for created variable\r\n self.send(\"#{k}=\", v)\r\n }\r\n self.class.all.push(self)\r\n end",
"def build!(hash)\n hash.must(::Hash) { raise ArgumentError, \"#{self} expects Hash, but got #{hash.class}\" }\n\n if hash.size != variables.size\n keys1 = variables.keys\n keys2 = hash.keys.map(&:to_s)\n minus = (keys1 - keys2).map{|i| \"-#{i}\"}\n plus = (keys2 - keys1).map{|i| \"+#{i}\"}\n \n msg = \"#{self} expects #{variables.size}, but got #{hash.size} (%s)\" % (minus + plus).join(\",\")\n raise Typed::SizeMismatch, msg\n end\n\n # 'build' just ignore unknown fields, but 'build!' raise errors\n obj = new\n hash.each_pair do |k,v|\n obj[k] = v\n end\n return obj\n end",
"def initialize(hash)\n @cw_id = hash[\"cw_id\"]\n @cik = hash[\"cik\"]\n @name = hash[\"company_name\"]\n @irs_number = hash[\"irs_number\"]\n @sic_code = hash[\"sic_code\"]\n @industry = hash[\"industry_name\"]\n @sic_sector = hash[\"sic_sector\"]\n @sector_name = hash[\"sector_name\"]\n @source_type = hash[\"source_type\"]\n @address = hash[\"raw_address\"]\n @country = hash[\"country_code\"]\n @state = hash[\"subdiv_code\"]\n @top_parent_id = hash[\"top_parent_id\"]\n @num_parents = hash[\"num_parents\"]\n @num_children = hash[\"num_children\"]\n @max_year = hash[\"max_year\"]\n @min_year = hash[\"min_year\"]\n end",
"def from_hash(hash)\n instance = allocate\n instance.instance_variable_set :@attributes, hash.freeze\n instance\n end",
"def from_hash(hash)\n hash = DEFAULTS.merge(hash)\n hash['spdx_id'] = hash.delete('spdx-id')\n ordered_array = hash.values_at(*members.map(&:to_s))\n new(*ordered_array)\n end",
"def initialize(hash=nil)\n @table = HashWithIndifferentAccess.new\n\n for k,v in hash\n @table[k] = v\n new_ostruct_member(k)\n end if hash\n end",
"def from_hash(hash)\n hash.each_pair do |key, value|\n\n # We need to catch hashes representing child objects\n # If the hash key:value is a of a Hash/BSON:Ordered hash\n if hash[key].class == Hash || hash[key].class == BSON::OrderedHash\n # If we have a classname we know we need to return to an object\n if hash[key][\"@classname\"]\n self.instance_variable_set(key, ::Object::full_const_get(hash[key][\"@classname\"]).new(hash[key])) unless key.to_s.start_with?(\"_\")\n else\n self.instance_variable_set(key, value) unless key.to_s.start_with?(\"_\")\n end\n else\n self.instance_variable_set(key, value) unless key.to_s.start_with?(\"_\")\n end\n end\n end",
"def from_hash(hash)\n hash.each_pair do |key, value|\n\n # We need to catch hashes representing child objects\n # If the hash key:value is a of a Hash/BSON:Ordered hash\n if hash[key].class == Hash || hash[key].class == BSON::OrderedHash\n # If we have a classname we know we need to return to an object\n if hash[key][\"@classname\"]\n self.instance_variable_set(key, ::Object::full_const_get(hash[key][\"@classname\"]).new(hash[key])) unless key.to_s.start_with?(\"_\")\n else\n self.instance_variable_set(key, value) unless key.to_s.start_with?(\"_\")\n end\n else\n self.instance_variable_set(key, value) unless key.to_s.start_with?(\"_\")\n end\n end\n end",
"def initialize(hash)\n @hash = hash\n @data = resourcify_data\n end",
"def from_hash hash\n @id= hash['id']\n\n @admin= hash['admin']\n @username= hash['username']\n @timezone= hash['timezone']\n @email_address= hash['email_address']\n\n @password = nil\n\n @created_at= DateTime.parse(hash['created_at'])\n @updated_at= DateTime.parse(hash['updated_at'])\n end",
"def hash_to_obj hash\n OpenStruct.new(hash) rescue raise ConfigError, \"Can't convert setup to object\"\n end",
"def initialize(hash)\n load_hash(hash)\n end",
"def from_hash( h)\n\t\th.each { |name,attributes|\n\t\t\tklass = Klass.new\n\t\t\tklass.from_hash( { name => attributes } )\n\t\t\tself.add_class( klass)\n\t\t}\n\n\t\t# this is an experiment in handling \"through\" attributes\n\t\t# i.e. enriching the model with the join classes\n\tend",
"def initialize(*args)\n super\n # hash = {}\n end",
"def build_object(resp)\n return resp unless resp.respond_to?(:merge)\n @build_object ||= final_object_class.new(resp.merge(additional_hash_to_serialize_after_response))\n end",
"def from_hash(hash)\n ordered_array = hash.values_at(*members.map(&:to_s))\n new(*ordered_array)\n end",
"def __convert hash #:nodoc:\n instance = self.class.new\n hash.each do |k, v|\n k = k.to_s if !k.respond_to?(:to_sym) && k.respond_to?(:to_s)\n instance.new_ostruct_member k\n if v.is_a?(Hash)\n v = v[\"type\"] == \"hash\" ? v[\"contents\"] : __convert(v)\n elsif v.is_a?(Array)\n v = v.map{|e| e.instance_of?(Hash) ? __convert(e) : e}\n end\n instance.send \"#{k}=\".to_sym, v\n end\n instance\n end",
"def initialize(hash)\n\t\t@id = hash['id']\n\t\t@first_name = hash['first_name']\n\t\t@last_name = hash['last_name']\n\t\t@mentor = hash['mentor']\n\tend",
"def initialize(hash={})\n @name = validate_name(hash[:name])\n @description = hash[:description]\n @snmp_opts = hash[:snmp_opts]\n\n save # Save a copy of self to Redis on creation\n end",
"def initialize\n @hash_dict = {}\n end",
"def initialize(hash=nil)\n @attributes = hash\n @attributes ||= {}\n end",
"def initialize(hash={})\n self.init_attrs_from_hash(hash)\n end",
"def from_hash(hash)\n apply_nested_hash(hash)\n end",
"def initialize(hash)\n # @id = hash[\"id\"]\n # @street_address = hash[\"street_address\"]\n # @city = hash[\"city\"]\n # @state = hash[\"state\"]\n # @zipcode = hash[\"zipcode\"]\n # @country = hash[\"country\"]\n\n #add in correct details\n end",
"def from_hash(hash)\n @data_object.user_acc_name = hash['user_acc_name']\n @data_object.user_affiliate = hash['user_affiliate']\n @user_over_13 = hash['user_over_13']\n\n contact.from_hash(hash)\n end",
"def initialize(hash)\n @name = hash[\"campaign\"] #decided to change it to \"name\" since this is the campaign class\n date_elements = hash[\"date\"].split(\"/\") #date is being passed in as a string, need this array to create the Date object in the next line\n @date = Date.new(date_elements[2].to_i + 2000, date_elements[0].to_i, date_elements[1].to_i) #added 2000 to year since the program was considering it as the year 15; this creates the date object\n @spend = hash[\"spend\"].to_f #use .to_f to make sure spend comes in as a float instead of a string\n @impressions = hash[\"impressions\"].to_i #need it as an integer for counting purposes later\n @actions = JSON.parse(hash[\"actions\"])#ensures that each action comes in as an array instead of a string\n @@all << self #shovels it into the all array\n end",
"def initialize(hash)\n hash.each do |k, v|\n self.send(\"#{k}=\", v) if self.respond_to?(\"#{k}=\")\n end\n @id = hash[\"id\"]\n end",
"def initialize (hash)\n hash.each {|key, value|\n self.class.attr_accessor(key)\n self.send((\"#{key}=\"), value)\n }\n @@all << self\n end",
"def initialize(hash={})\n @data = Hash.new\n hash.each do |key, value|\n self[key] = value\n end\n end",
"def create_from_hash(hash, opts={})\n create_opts = update_or_create_options(hash, opts)\n create { |instance| instance.set(create_opts) }\n end",
"def initialize(hash={})\n # assign the attributes here (???)\n hash.each do |k, v| # name = id, name, etc.\n self.send(\"#{k}=\", v)\n # self.k = v # there's no '.k' method\n #binding.pry\n end\n end",
"def initialize(hash) #.new\n @name = hash[:name][0]\n @region = hash[:region]\n @population = hash[:population]\n @capital = hash[:capital]\n @flag_link = hash[:flag_link]\n @@all << self\n #binding.pry\n end",
"def initialize(hash = {})\n super(hash)\n\n @action = extract_value(hash, :action)\n @clientId = extract_value(hash, :clientId)\n @clientIdAlias = extract_value(hash, :clientIdAlias)\n @clientIdAliasUsed = extract_boolean_value(hash, :clientIdAliasUsed)\n @expiresAt = extract_integer_value(hash, :expiresAt)\n @subject = extract_value(hash, :subject)\n @scopes = extract_value(hash, :scopes)\n @existent = extract_boolean_value(hash, :existent)\n @usable = extract_boolean_value(hash, :usable)\n @sufficient = extract_boolean_value(hash, :sufficient)\n @refreshable = extract_boolean_value(hash, :refreshable)\n @responseContent = extract_value(hash, :responseContent)\n @properties = extract_array_value(hash, :scopes) do |element|\n Authlete::Model::Property.parse(element)\n end\n end",
"def initialize( hash )\n\t\t@object_classes = self.parse_objectclasses( hash['objectClasses'] || [] )\n\t\t@attribute_types = self.parse_attribute_types( hash['attributeTypes'] || [] )\n\t\t@ldap_syntaxes = self.parse_ldap_syntaxes( hash['ldapSyntaxes'] || [] )\n\t\t@matching_rules = self.parse_matching_rules( hash['matchingRules'] || [] )\n\t\t@matching_rule_uses = self.parse_matching_rule_uses( hash['matchingRuleUse'] || [] )\n\tend",
"def from_hash(hash)\n super(hash)\n verify\n end",
"def objects_from_serialized_hash(hash) # :nodoc:\n klass, attributes = Helpers.to_class_and_attributes(hash)\n klass.from_seedable_attributes(attributes)\n end",
"def initialize (hash)\n @name = hash [:name]\n @color = hash [:color]\n @robots = hash [:robots]\n @moon_count = hash [:moon_count]\n @cats = hash [:cats]\n #@solar_rotation = solar_rotation .....I dont really understand what a solar rotation is.... it's confusing.....\n @distance_from_the_sun = hash [:distance_from_the_sun]\n end",
"def initialize(hash = nil)\n @arguments = 0\n return if hash.nil?\n @name = hash['name']\n @arguments = hash['arguments']\n end",
"def _from_hash(hsh)\n hsh.each do |k, v|\n v = restore_hash(v)\n v = v.map { |iv| restore_hash(iv) } if v.is_a?(Array)\n send(:\"#{k}=\", v)\n end\n self\n end",
"def from_hash(hash)\n struct = SparkleStruct.new\n struct._camel_keys_set(:auto_discovery)\n struct._load(hash)\n struct._camel_keys_set(nil)\n struct\n end",
"def from_hash(hash)\n struct = SparkleStruct.new\n struct._camel_keys_set(:auto_discovery)\n struct._load(hash)\n struct._camel_keys_set(nil)\n struct\n end",
"def initialize(hash={})\n self.attributes = hash\n end",
"def initialize(raw_hash)\n if valid_hash?(raw_hash)\n self.replace(raw_hash)\n @version, @cost, @salt, @checksum = split_hash(self)\n else\n raise Errors::InvalidHash.new(\"invalid hash\")\n end\n end",
"def initialize(raw_hash)\n if valid_hash?(raw_hash)\n self.replace(raw_hash)\n @version, @cost, @salt, @checksum = split_hash(self)\n else\n raise Errors::InvalidHash.new(\"invalid hash\")\n end\n end",
"def build(base, object, type = nil, selected_fields = nil)\n return object unless object.is_a?(Hash)\n if _loading?\n Factory.from_db(klass, object, nil, selected_fields)\n else\n Factory.build(klass, object)\n end\n end",
"def initialize(hash)\n super(hash)\n @size = hash[\"size\"]\n end",
"def initialize(raw_hash)\n if valid_hash?(raw_hash)\n self.replace(raw_hash)\n @cost, @salt, @digest = split_hash(self.to_s)\n else\n raise Errors::InvalidHash.new(\"invalid hash\")\n end\n end",
"def instantiate hash, extra_attributes={}\n return hash unless hash.kind_of? Hash\n# init = hash.values_at(*@singulars).compact.first\n init = hash[@singular]\n inits = hash[@plural]\n if init\n new init.merge extra_attributes\n elsif inits\n inits.map {|each| new each.merge extra_attributes}\n else\n hash\n end\n end",
"def from_hash(values)\n @data_object.team_challenge = values['team_challenge']\n @data_object.team_level = values['team_level']\n @data_object.team_name = values['team_name']\n\n# @mgr_email = values['mgr_email']\n\n names = values['tm_name']\n\n TeamMember::MEMBERS_PER_TEAM.times do |i|\n if names[i].empty?\n @members[i].clear\n else\n @members[i].tm_name = names[i]\n @members[i].tm_grade = values['tm_grade'][i].to_i\n @members[i].tm_dob_mon = values['tm_dob_mon'][i]\n @members[i].tm_dob_day = values['tm_dob_day'][i]\n @members[i].tm_dob_year = values['tm_dob_year'][i]\n @members[i].tm_sex = values['tm_sex'][i]\n end\n end\n end",
"def hash\n { hash: @hash, hashType: @hash_type }\n end",
"def initialize(raw_hash)\n raise Errors::InvalidHash, 'invalid hash' unless valid_hash?(raw_hash)\n\n replace(raw_hash)\n\n @cost, @salt, @digest = split_hash(to_s)\n end",
"def initialize( confighash={} )\n\t\tihash = internify_keys( untaint_values(confighash) )\n\t\tmergedhash = DEFAULTS.merge( ihash, &HashMergeFunction )\n\n\t\t@struct = ConfigStruct.new( mergedhash )\n\t\t@create_time = Time.now\n\t\t@name = nil\n\t\t@loader = nil\n\n\t\tsuper()\n\tend",
"def initialize(*args)\n @hash = HashWithIndifferentAccess.new(*args)\n end",
"def create(hash={})\n model = self.new(hash)\n model.save\n model\n end",
"def from_hash(hash:, klass:)\n validate_class_kit(klass)\n\n @hash_helper.indifferent!(hash)\n entity = klass.new\n attributes = @attribute_helper.get_attributes(klass)\n attributes.each do |attribute|\n key = attribute[:name]\n type = attribute[:type]\n\n #if the hash value is nil skip it\n next if hash[key].nil?\n\n value = if is_class_kit?(type)\n from_hash(hash: hash[key], klass: type)\n elsif type == Array\n hash[key].map do |array_element|\n if attribute[:collection_type].nil?\n array_element\n else\n if is_class_kit?(attribute[:collection_type])\n from_hash(hash: array_element, klass: attribute[:collection_type])\n else\n @value_helper.parse(type: attribute[:collection_type], value: array_element)\n end\n end\n end\n else\n hash[key]\n end\n\n entity.public_send(:\"#{key}=\", value)\n end\n\n entity\n end",
"def from_h(hash, converter = nil)\n instance = new\n\n hash.each do |k, v|\n v = convert(v, k, converter) if converter\n instance.instance_variable_set(:\"@#{k}\", v)\n end\n\n instance\n end",
"def initialize(hash_that_represents_json)\n\t\t@data = hash_that_represents_json\n\tend",
"def hash_for_merging(hash)\n new_hash = { id: hash['message_id'].to_i,\n date: Time.at(hash['date'].to_i),\n from: User.new(hash['from'], @bot),\n chat: Chat.new(hash['chat'], @bot) }\n\n type = TYPES.find { |t| hash[t.to_s] }\n new_hash[type] = hash[type.to_s] # TODO: fail if type not found\n\n new_hash\n end",
"def initialize(hash)\n @header = Msg::Header.new(hash)\n @body = Msg::Body.new(content_is_json?, hash)\n end",
"def build_resource(hash = {})\n self.resource = resource_class.new(hash)\n end",
"def initialize()\n @hash = {}\n @values = []\n end",
"def build\n fail \"Please provide a value for key, currently: #{key}\" if key.nil?\n\n if in_key\n { in_key.to_sym => { key => data } }\n else\n process_data\n transform_to_hash\n end\n end",
"def initialize(build)\n @build = build\n @hash = {}\n @already_run = []\n end",
"def new_from_hash_marketplace(h)\n self.url = h\n h=h.split('/')\n h=h[h.size-2]\n self.original_id = h\n return self\n end",
"def initialize(hash, type, dump)\n self.hash = hash\n self.type = type.to_sym\n self.dump = dump\n end",
"def initialize(hash_data, opts: {})\n @hsh = hash_data\n @opts = opts\n\n @title = @hsh[:title]\n @body = @hsh[:body_hash]\n end",
"def initialize(hash)\n @color = hash[:color]\n @scent = hash[:scent]\n end",
"def initialize(hash = nil)\n hash.each { |key, value| self[key] = value } if !hash.nil? && hash.is_a?(Hash)\n end",
"def create(hash)\n NotImplementedError\n end",
"def from_h(hash, converter = nil)\n instance = new\n\n hash.each do |k, v|\n v = instance.convert(v, k, converter) if converter\n instance.send(:\"#{k}=\", v)\n end\n\n instance\n end",
"def init_jaxb_json_hash(_o)\n super _o\n @id = String.from_json(_o['id']) unless _o['id'].nil?\n @version = String.from_json(_o['version']) unless _o['version'].nil?\n @description = String.from_json(_o['description']) unless _o['description'].nil?\n @url = String.from_json(_o['url']) unless _o['url'].nil?\n @name = String.from_json(_o['name']) unless _o['name'].nil?\n @organization = Org::Apache::Archiva::Metadata::Model::Organization.from_json(_o['organization']) unless _o['organization'].nil?\n @issueManagement = Org::Apache::Archiva::Metadata::Model::IssueManagement.from_json(_o['issueManagement']) unless _o['issueManagement'].nil?\n @scm = Org::Apache::Archiva::Metadata::Model::Scm.from_json(_o['scm']) unless _o['scm'].nil?\n @ciManagement = Org::Apache::Archiva::Metadata::Model::CiManagement.from_json(_o['ciManagement']) unless _o['ciManagement'].nil?\n if !_o['licenses'].nil?\n @licenses = Array.new\n _oa = _o['licenses']\n _oa.each { | _item | @licenses.push Org::Apache::Archiva::Metadata::Model::License.from_json(_item) }\n end\n if !_o['mailingLists'].nil?\n @mailingLists = Array.new\n _oa = _o['mailingLists']\n _oa.each { | _item | @mailingLists.push Org::Apache::Archiva::Metadata::Model::MailingList.from_json(_item) }\n end\n if !_o['dependencies'].nil?\n @dependencies = Array.new\n _oa = _o['dependencies']\n _oa.each { | _item | @dependencies.push Org::Apache::Archiva::Metadata::Model::Dependency.from_json(_item) }\n end\n @incomplete = Boolean.from_json(_o['incomplete']) unless _o['incomplete'].nil?\n end",
"def create_version_hash\n new_version = {}\n new_version['created'] = ''\n new_version['message'] = ''\n new_version['user'] = {}\n # user is #name, # address.\n new_version['user']['name'] = ''\n new_version['user']['address'] = ''\n new_version['state'] = {}\n new_version\n end",
"def create_from_hash hash\n values = values_from_hash hash\n unless obj = find(:first, :conditions => values)\n return nil if values[:id]\n obj = create!(values)\n raise ArgumentError, \"#{obj.errors.to_s}\" unless obj.errors.empty?\n end\n obj\n end",
"def initialize result_hash={}\n @result_hash = result_hash\n end",
"def create_hash(&block); end",
"def create_hash(&block); end",
"def initialize(attrs={})\n from_hash(attrs)\n end",
"def build_request_data(hash)\n {\n :attributes! => {\n addressinfo: { \"xsi:type\" => \"ns2:Map\" },\n },\n username: @username,\n password: @password,\n addressinfo: {\n item: [\n { key: 'name', value: hash[:name] },\n { key: 'address1', value: hash[:address1] },\n { key: 'address2', value: hash[:address2] },\n { key: 'city', value: hash[:city] },\n { key: 'state', value: hash[:state] },\n { key: 'zip', value: hash[:zip] },\n { key: 'fflno', value: hash[:fflno] },\n { key: 'fflexp', value: hash[:fflexp] }\n ]\n },\n testing: @testing\n }\n end",
"def init_jaxb_json_hash(_o)\n @groupId = String.from_json(_o['groupId']) unless _o['groupId'].nil?\n @artifactId = String.from_json(_o['artifactId']) unless _o['artifactId'].nil?\n @version = String.from_json(_o['version']) unless _o['version'].nil?\n @packaging = String.from_json(_o['packaging']) unless _o['packaging'].nil?\n @className = String.from_json(_o['className']) unless _o['className'].nil?\n if !_o['repositories'].nil?\n @repositories = Array.new\n _oa = _o['repositories']\n _oa.each { | _item | @repositories.push String.from_json(_item) }\n end\n @bundleVersion = String.from_json(_o['bundleVersion']) unless _o['bundleVersion'].nil?\n @bundleSymbolicName = String.from_json(_o['bundleSymbolicName']) unless _o['bundleSymbolicName'].nil?\n @bundleExportPackage = String.from_json(_o['bundleExportPackage']) unless _o['bundleExportPackage'].nil?\n @bundleExportService = String.from_json(_o['bundleExportService']) unless _o['bundleExportService'].nil?\n @classifier = String.from_json(_o['classifier']) unless _o['classifier'].nil?\n @includePomArtifacts = Boolean.from_json(_o['includePomArtifacts']) unless _o['includePomArtifacts'].nil?\n @queryTerms = String.from_json(_o['queryTerms']) unless _o['queryTerms'].nil?\n @bundleImportPackage = String.from_json(_o['bundleImportPackage']) unless _o['bundleImportPackage'].nil?\n @bundleRequireBundle = String.from_json(_o['bundleRequireBundle']) unless _o['bundleRequireBundle'].nil?\n @pageSize = Fixnum.from_json(_o['pageSize']) unless _o['pageSize'].nil?\n @selectedPage = Fixnum.from_json(_o['selectedPage']) unless _o['selectedPage'].nil?\n end",
"def initialize(order_hash)\n @id = order_hash['id']\n @number = order_hash['number']\n @special_instructions = order_hash['special_instructions']\n @total = order_hash['total']\n @total_quantity = order_hash['total_quantity']\n @created_at = order_hash['created_at']\n @updated_at = order_hash['updated_at']\n end",
"def from_db_hash *args\n from_hash *args\n end",
"def build_from_hash(attributes)\n return nil unless attributes.is_a?(Hash)\n self.class.swagger_types.each_pair do |key, type|\n if type =~ /^Array<(.*)>/i\n if attributes[self.class.attribute_map[key]].is_a?(Array)\n self.send(\"#{key}=\", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )\n else\n #TODO show warning in debug mode\n end\n elsif !attributes[self.class.attribute_map[key]].nil?\n self.send(\"#{key}=\", _deserialize(type, attributes[self.class.attribute_map[key]]))\n else\n # data not found in attributes(hash), not an issue as the data can be optional\n end\n end\n\n self\n end",
"def build_from_hash(attributes)\n return nil unless attributes.is_a?(Hash)\n self.class.swagger_types.each_pair do |key, type|\n if type =~ /^Array<(.*)>/i\n if attributes[self.class.attribute_map[key]].is_a?(Array)\n self.send(\"#{key}=\", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )\n else\n #TODO show warning in debug mode\n end\n elsif !attributes[self.class.attribute_map[key]].nil?\n self.send(\"#{key}=\", _deserialize(type, attributes[self.class.attribute_map[key]]))\n else\n # data not found in attributes(hash), not an issue as the data can be optional\n end\n end\n\n self\n end",
"def build_from_hash(attributes)\n return nil unless attributes.is_a?(Hash)\n self.class.swagger_types.each_pair do |key, type|\n if type =~ /^Array<(.*)>/i\n if attributes[self.class.attribute_map[key]].is_a?(Array)\n self.send(\"#{key}=\", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )\n else\n #TODO show warning in debug mode\n end\n elsif !attributes[self.class.attribute_map[key]].nil?\n self.send(\"#{key}=\", _deserialize(type, attributes[self.class.attribute_map[key]]))\n else\n # data not found in attributes(hash), not an issue as the data can be optional\n end\n end\n\n self\n end"
] |
[
"0.8011074",
"0.7470833",
"0.7457607",
"0.7256629",
"0.72455454",
"0.70060325",
"0.6973257",
"0.6955014",
"0.69459796",
"0.69398683",
"0.69363195",
"0.6917627",
"0.6872358",
"0.6796184",
"0.6783521",
"0.67575246",
"0.67575246",
"0.67560464",
"0.67514306",
"0.67136854",
"0.66667664",
"0.6623634",
"0.661206",
"0.66098964",
"0.66098964",
"0.6591922",
"0.65713006",
"0.6547411",
"0.6524743",
"0.6524143",
"0.6513636",
"0.650189",
"0.6498057",
"0.6485853",
"0.6483371",
"0.6475685",
"0.6459916",
"0.6454491",
"0.6440182",
"0.6434778",
"0.6401363",
"0.63977015",
"0.6396885",
"0.63910425",
"0.63720834",
"0.6363958",
"0.63597506",
"0.6313429",
"0.6295958",
"0.62923384",
"0.62915224",
"0.62704456",
"0.62703115",
"0.62622243",
"0.62515473",
"0.6249854",
"0.6242987",
"0.6242987",
"0.62426233",
"0.62408733",
"0.62407595",
"0.62321323",
"0.62298346",
"0.622897",
"0.622756",
"0.62245685",
"0.62217826",
"0.6218501",
"0.6210329",
"0.62091905",
"0.620342",
"0.6201614",
"0.6178616",
"0.6166234",
"0.61611027",
"0.6140086",
"0.6126761",
"0.61154264",
"0.61059844",
"0.60980254",
"0.60971874",
"0.6090533",
"0.6064119",
"0.6061236",
"0.6060324",
"0.60599816",
"0.60420287",
"0.6039776",
"0.603712",
"0.6033585",
"0.6030829",
"0.6023582",
"0.6023582",
"0.6016123",
"0.60155296",
"0.6014705",
"0.6008574",
"0.60031897",
"0.60024095",
"0.60024095",
"0.60024095"
] |
0.0
|
-1
|
Deserializes the data based on type
|
def _deserialize(type, value)
case type.to_sym
when :Time
Time.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
# models (e.g. Pet) or oneOf
klass = OpenapiClient.const_get(type)
klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Telstra_Messaging.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = FattureInCloud.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = IFClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = WineShipping.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = UltracartClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n DearInventoryRuby.const_get(type).build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Mooncard.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Aimastering.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Harbor1Client.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Intrinio.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /^(true|t|yes|y|1)$/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Pier.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = CrelateClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = CrelateClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = CrelateClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = CrelateClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = CrelateClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = WellsFargoAchClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ArtikCloud.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Dkron.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n MailSlurpClient.const_get(type).build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n MailSlurpClient.const_get(type).build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Esi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Esi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Esi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :Time\n Time.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n # models (e.g. Pet) or oneOf\n klass = Fastly.const_get(type)\n klass.respond_to?(:fastly_one_of) ? klass.build(value) : klass.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :Time\n Time.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n # models (e.g. Pet) or oneOf\n klass = Fastly.const_get(type)\n klass.respond_to?(:fastly_one_of) ? klass.build(value) : klass.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :Time\n Time.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n # models (e.g. Pet) or oneOf\n klass = Fastly.const_get(type)\n klass.respond_to?(:fastly_one_of) ? klass.build(value) : klass.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :Time\n Time.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n # models (e.g. Pet) or oneOf\n klass = Fastly.const_get(type)\n klass.respond_to?(:fastly_one_of) ? klass.build(value) : klass.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n ::DateTime.parse(value)\n when :Date\n ::Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Models.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n ::DateTime.parse(value)\n when :Date\n ::Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Models.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :Time\n Time.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n # models (e.g. Pet) or oneOf\n klass = Hubspot::Cms::Performance.const_get(type)\n klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = SmoochApi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Tradenity.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Tradenity.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = SamplifyAPIClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = OpsgenieClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = LemonWayClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = BudgeaClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = BudgeaClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :Boolean\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n Nodeum.const_get(type).build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TextMagic.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TextMagic.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TextMagic.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n Date.parse value\n when :Date\n Date.parse value\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else\n # model\n temp_model = GroupDocsViewerCloud.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n Date.parse value\n when :Date\n Date.parse value\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else\n # model\n temp_model = GroupDocsViewerCloud.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n Date.parse value\n when :Date\n Date.parse value\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else\n # model\n temp_model = GroupDocsViewerCloud.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = ConnectWise.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = NSXT.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = NSXT.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = NSXT.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TreezorClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TreezorClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TreezorClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = SwiftApi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = SwiftApi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = TripletexApi.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = unwiredClient.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end",
"def _deserialize(type, value)\n case type.to_sym\n when :DateTime\n DateTime.parse(value)\n when :Date\n Date.parse(value)\n when :String\n value.to_s\n when :Integer\n value.to_i\n when :Float\n value.to_f\n when :BOOLEAN\n if value.to_s =~ /\\A(true|t|yes|y|1)\\z/i\n true\n else\n false\n end\n when :Object\n # generic object (usually a Hash), return directly\n value\n when /\\AArray<(?<inner_type>.+)>\\z/\n inner_type = Regexp.last_match[:inner_type]\n value.map { |v| _deserialize(inner_type, v) }\n when /\\AHash<(?<k_type>.+?), (?<v_type>.+)>\\z/\n k_type = Regexp.last_match[:k_type]\n v_type = Regexp.last_match[:v_type]\n {}.tap do |hash|\n value.each do |k, v|\n hash[_deserialize(k_type, k)] = _deserialize(v_type, v)\n end\n end\n else # model\n temp_model = Quandoo.const_get(type).new\n temp_model.build_from_hash(value)\n end\n end"
] |
[
"0.7330926",
"0.7274019",
"0.72504056",
"0.7245751",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.72291344",
"0.7218884",
"0.7213926",
"0.71909",
"0.7183136",
"0.71796805",
"0.71796805",
"0.71796805",
"0.71796805",
"0.71796805",
"0.71796805",
"0.71796805",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71791923",
"0.71712995",
"0.71712995",
"0.71712995",
"0.71712995",
"0.71712995",
"0.71632504",
"0.71549904",
"0.71473306",
"0.71413666",
"0.71413666",
"0.7141116",
"0.7141116",
"0.7141116",
"0.7133874",
"0.7133874",
"0.7133874",
"0.7133874",
"0.71333444",
"0.71333444",
"0.7127688",
"0.7125744",
"0.71210617",
"0.71210617",
"0.71190786",
"0.71184087",
"0.711393",
"0.7113519",
"0.7113519",
"0.7113516",
"0.71119875",
"0.71119875",
"0.71119875",
"0.7105169",
"0.7105169",
"0.7105169",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7104928",
"0.7102596",
"0.7102596",
"0.7102596",
"0.7101596",
"0.7101596",
"0.7101596",
"0.70996517",
"0.70996517",
"0.7097952",
"0.7097185",
"0.70965225"
] |
0.0
|
-1
|
Returns the string representation of the object
|
def to_s
to_hash.to_s
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def to_s\n @object.to_s\n end",
"def to_s\n object.to_s\n end",
"def serialize(object)\n object.to_s\n end",
"def to_s\n self.inspect\n end",
"def to_s\n @string || @object.to_s('F')\n end",
"def to_s\n @string || @object.to_s('F')\n end",
"def to_s\n \"#<#{self.class.name}:#{object_id} #{info}>\"\n end",
"def to_s\n \"#<#{self.class.name}:#{object_id}> @names=#{names}>\"\n end",
"def to_s\n self.inspect\n end",
"def to_s\n toString()\n end",
"def to_s\r\n dump\r\n end",
"def to_s\n inspect\n end",
"def to_s\n toString\n end",
"def toString\n #Not sure if we want this or just use the getters for more\n #selective formatting\n end",
"def to_s\n\t\t\t@string\n\t\tend",
"def to_s\n stringify\n end",
"def to_s\n to_h.to_s\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def inspect\n serialize.to_s\n end",
"def inspect\n to_s\n end",
"def to_s\n @string ||= Builder::ToString.new(self).string\n end",
"def to_s\n self\n end",
"def to_s()\n serialize.to_s()\n end",
"def to_s()\n serialize.to_s()\n end",
"def to_s\n string\n end",
"def to_s\n inspect\n end",
"def to_s\n inspect\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n self.to_s\n end",
"def inspect\n self.to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def to_s\n end",
"def to_s\n end",
"def to_s\n end",
"def to_s\n end",
"def inspect\n to_s.inspect\n end",
"def inspect()\n serialize.to_s()\n end",
"def inspect()\n serialize.to_s()\n end",
"def inspect\n return self.to_s\n end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end",
"def to_s; end"
] |
[
"0.901024",
"0.89506465",
"0.84703195",
"0.83409667",
"0.8337169",
"0.8337169",
"0.8332247",
"0.82546586",
"0.8145818",
"0.8144667",
"0.81357557",
"0.812714",
"0.8093436",
"0.8086725",
"0.8073356",
"0.8039774",
"0.80308646",
"0.80064154",
"0.80064154",
"0.80064154",
"0.80064154",
"0.7962831",
"0.7962831",
"0.7962831",
"0.7962831",
"0.7954296",
"0.79446983",
"0.7919419",
"0.7909274",
"0.78848016",
"0.78848016",
"0.78841925",
"0.788328",
"0.788328",
"0.78758216",
"0.78758216",
"0.78758216",
"0.78758216",
"0.78758216",
"0.78758216",
"0.78758216",
"0.7866813",
"0.7866813",
"0.7865939",
"0.7865939",
"0.7850519",
"0.7850519",
"0.7850519",
"0.7850519",
"0.7808076",
"0.7784745",
"0.7784745",
"0.7767656",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824",
"0.77608824"
] |
0.0
|
-1
|
to_body is an alias to to_hash (backward compatibility)
|
def to_body
to_hash
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def to_body\r\n to_hash\r\n end",
"def to_body\n to_hash\nend",
"def to_body\n to_hash\nend"
] |
[
"0.8429809",
"0.8347024",
"0.8347024"
] |
0.0
|
-1
|
Returns the object in the form of hash
|
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def to_hash\n object\n end",
"def hash\r\n return to_s.hash\r\n end",
"def hash\n to_a.hash\n end",
"def hash\n [_hash, name, owner].hash\n end",
"def hash\n return to_s.hash\n end",
"def hash\n @hash\n end",
"def hash\n @hash.hash\n end",
"def hash\n @hash ||= self.to_a.hash\n end",
"def to_hash\n @hash\n end",
"def to_hash\n @hash\n end",
"def hash\n to_s.hash\n end",
"def to_hash\n @hash\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @object\n end",
"def to_h\n @hash\n end",
"def to_h\n @hash\n end",
"def hash\n to_h.hash ^ self.class.hash\n end",
"def as_hash\n @hash\n end",
"def __getobj__\n @hashobj\n end",
"def to_hash() end",
"def hash\n to_s.hash\n end",
"def hash\n to_s.hash\n end",
"def hash\n object_id\n end",
"def to_hash\n @_hash_\n end",
"def hash\n\t\treturn self.name.to_s.hash\n\tend",
"def to_hash\n to_a.hash\n end",
"def hash\n { hash: @hash, hashType: @hash_type }\n end",
"def hash\n data.hash\n end",
"def hash\n [self.class, to_h].hash\n end",
"def hash\n [self.class, to_h].hash\n end",
"def hash\n [self.class, to_h].hash\n end",
"def hash\r\n id.hash\r\n end",
"def hash\n \"#{self.class.name}-#{self.id}-#{@__metadata__.cas}-#{@__attributes__.hash}\".hash\n end",
"def hash\n attributes.hash\n end",
"def hash\n attributes.hash\n end",
"def hash\n attributes.hash\n end",
"def hash #:nodoc:\n __getobj__.hash ^ self.class.hash\n end",
"def hash\n self.to_f.hash\n end",
"def hash\n end",
"def hash\n end",
"def hash\n end",
"def to_hash\n return self\n end",
"def to_hash(object)\n validate_class_kit(object.class)\n\n @hash_helper.to_hash(object)\n end",
"def hash\n return @id.hash\n end",
"def to_h\n Hash[ self ]\n end",
"def to_hash\n Hash[self]\n end",
"def to_h\n @hash.dup\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def to_h\n @hash.dup\n end",
"def hash\n model.hash + key.hash\n end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def hash\n [self.class, to_s].hash\n end",
"def hash\n id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n self.atoms.hash\n end",
"def to_h\n Hash[self]\n end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash\n\t\tvalue.hash\n\tend",
"def hash\n [description, routing_number, account_number, account_type, signatory, metadata, id, signature_url, bank_name, verified, date_created, date_modified, deleted, object].hash\n end",
"def hash\n @id.hash\n end",
"def hash\n id.hash\n end",
"def hash\n self.class.name.hash\n end",
"def to_h\n @_hash.dup\n end",
"def hash\n\t\t[@id].hash\n\tend",
"def hash\n [self.class, to_s].hash\n end",
"def __hash\n @hash\n end"
] |
[
"0.8270299",
"0.78767854",
"0.78726953",
"0.7802364",
"0.7789188",
"0.77806795",
"0.7775915",
"0.7767511",
"0.7760525",
"0.7760525",
"0.77559966",
"0.7731286",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7713916",
"0.7647042",
"0.7647042",
"0.7626769",
"0.760354",
"0.7595938",
"0.7582562",
"0.7579971",
"0.7579971",
"0.7535553",
"0.7495252",
"0.7433835",
"0.7411177",
"0.73843014",
"0.73661345",
"0.73658615",
"0.73658615",
"0.73658615",
"0.73600674",
"0.7359121",
"0.73590857",
"0.73590857",
"0.73590857",
"0.7340058",
"0.73356754",
"0.7329828",
"0.7329828",
"0.7329828",
"0.73170114",
"0.730566",
"0.73028016",
"0.7294603",
"0.72854036",
"0.72643596",
"0.72637254",
"0.72620076",
"0.72620076",
"0.72620076",
"0.72620076",
"0.72620076",
"0.72620076",
"0.72620076",
"0.72620076",
"0.72620076",
"0.726188",
"0.72524244",
"0.72511965",
"0.72511965",
"0.72511965",
"0.72511965",
"0.72511965",
"0.72511965",
"0.72479564",
"0.72474235",
"0.72474235",
"0.7241066",
"0.7229342",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7228758",
"0.7224175",
"0.72185695",
"0.72126305",
"0.72116995",
"0.71945405",
"0.71828544",
"0.7181684",
"0.7171822",
"0.71657544"
] |
0.0
|
-1
|
Outputs nonarray value in the form of hash For object, use to_hash. Otherwise, just return the value
|
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def hash\n [value].hash\n end",
"def hash\n [value].hash\n end",
"def hash\n\t\tvalue.hash\n\tend",
"def hash\n value.hash\n end",
"def hash\n @value.hash\n end",
"def hash\r\n return to_s.hash\r\n end",
"def to_hash\n @value\n end",
"def to_hash\n @value\n end",
"def hash\n @hash || @hash = (value.hash * -1)\n end",
"def output_hash; end",
"def to_hash() end",
"def hash\n return to_s.hash\n end",
"def hash\n value_id.hash\n end",
"def to_hash\n call\n @hash = @value\n @hash\n end",
"def hash\n to_s.hash\n end",
"def hash\n to_s.hash\n end",
"def hash\n self.to_f.hash\n end",
"def hash\n to_s.hash\n end",
"def to_hash(obj = T.unsafe(nil)); end",
"def to_h\n @value\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map { |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map { |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map { |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map { |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def value_to_hash(value, options = T.unsafe(nil)); end",
"def to_s\r\n to_hash.to_s\r\n end",
"def _to_hash(value)\r\n if value.is_a?(Array)\r\n value.compact.map{ |v| _to_hash(v) }\r\n elsif value.is_a?(Hash)\r\n {}.tap do |hash|\r\n value.each { |k, v| hash[k] = _to_hash(v) }\r\n end\r\n elsif value.respond_to? :to_hash\r\n value.to_hash\r\n else\r\n value\r\n end\r\n end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def hash; end",
"def to_s\n to_hash.to_s\nend",
"def to_s\n to_hash.to_s\nend",
"def to_h(value)\n return value unless @to_h\n @to_h.call value\n end",
"def to_hash\n Hash[to_a]\n end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def to_hash; end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end",
"def _to_hash(value)\n if value.is_a?(Array)\n value.compact.map{ |v| _to_hash(v) }\n elsif value.is_a?(Hash)\n {}.tap do |hash|\n value.each { |k, v| hash[k] = _to_hash(v) }\n end\n elsif value.respond_to? :to_hash\n value.to_hash\n else\n value\n end\n end"
] |
[
"0.6719518",
"0.6719518",
"0.666832",
"0.66565555",
"0.6586841",
"0.6452931",
"0.6414911",
"0.6414911",
"0.6382046",
"0.6346188",
"0.6302933",
"0.62237245",
"0.6151989",
"0.6101756",
"0.60795677",
"0.60795677",
"0.60717124",
"0.6035991",
"0.6021168",
"0.5936472",
"0.5903488",
"0.5903488",
"0.5903488",
"0.5903488",
"0.5903488",
"0.5890367",
"0.5890367",
"0.5884459",
"0.5884459",
"0.58669275",
"0.58533067",
"0.58355993",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.58215266",
"0.5803003",
"0.5803003",
"0.57983655",
"0.578115",
"0.577359",
"0.577359",
"0.577359",
"0.577359",
"0.577359",
"0.577359",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771",
"0.5769771"
] |
0.0
|
-1
|
GET /mission_memberships GET /mission_memberships.json
|
def index
@mission_memberships = MissionMembership.all
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def memberships\n @list.client.get(\"#{url}/memberships\")\n end",
"def index\n @memberships = @user.memberships\n end",
"def GetMemberships params = {}\n\n params = params.merge(path: 'group_memberships.json')\n APICall(params)\n\n end",
"def list_memberships(user)\n get(\"/#{user}/lists/memberships.json\")\n end",
"def GetMembership id\n\n APICall(path: \"group_memberships/#{id}.json\")\n\n end",
"def set_mission_membership\n @mission_membership = MissionMembership.find(params[:id])\n end",
"def index\n @memberships = @organization.memberships.all\n end",
"def index\n @memberships = @user.memberships\n\n respond_to do |format|\n format.html # index.rhtml\n end\n end",
"def index\n @memberships = @community.memberships\n end",
"def show\n @memberships = @participant.memberships.all\n end",
"def index\n @memberships = Membership.all\n end",
"def index\n @memberships = Membership.all\n end",
"def index\n @memberships = Membership.all\n end",
"def show\n @membership = Adhocracy::Membership.find(params[:id])\n\n render json: @membership\n end",
"def mission_membership_params\n params.require(:mission_membership).permit(:user_id, :mission_id)\n end",
"def index\n @organization_memberships = OrganizationMembership.where(user_id: params['user_id'])\n authorize @organization_memberships\n\n render json: @organization_memberships\n end",
"def index\n authorize Group\n render :json => @group.group_memberships\n end",
"def index\n @user = User.find(params[:user_id])\n @lab_memberships = @user.lab_memberships\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @lab_memberships }\n end\n end",
"def memberships\n prefix = \"#{path_prefix}/memberships\"\n Ghee::API::Users::Memberships::Proxy.new(connection, prefix)\n end",
"def show\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @membership }\n end\n end",
"def list_memberships(user_id:)\n path = '/users/{userId}/memberships'\n .gsub('{userId}', user_id)\n\n if user_id.nil?\n raise Appwrite::Exception.new('Missing required parameter: \"userId\"')\n end\n\n params = {\n }\n \n headers = {\n \"content-type\": 'application/json',\n }\n\n @client.call(\n method: 'GET',\n path: path,\n headers: headers,\n params: params,\n response_type: Models::MembershipList\n )\n end",
"def lms_membership\n unless current_organization.lti_configuration.supports_membership_service?\n lms_name = current_organization.lti_configuration.lms_name(default_name: \"your learning management system\")\n msg = \"GitHub Classroom does not have access to your course roster on #{lms_name}. Please ensure that\n you've allowed GitHub Classroom to retrieve your course membership from #{lms_name} and try again.\"\n\n raise LtiImportError, msg\n end\n\n membership_service = GitHubClassroom::LTI::MembershipService.new(\n current_organization.lti_configuration.context_membership_url,\n current_organization.lti_configuration.consumer_key,\n current_organization.lti_configuration.shared_secret,\n lti_version: current_organization.lti_configuration.lti_version\n )\n\n begin\n membership_service.students(body_params: current_organization.lti_configuration.context_membership_body_params)\n rescue Faraday::ClientError, JSON::ParserError => error\n report_error(error)\n\n lms_name = current_organization.lti_configuration.lms_name(default_name: \"your learning management system\")\n msg = \"GitHub Classroom is unable to fetch membership from #{lms_name} at this time. If the problem persists,\n re-launch GitHub Classroom from your learning management system and try again.\"\n\n raise LtiImportError, msg\n end\n end",
"def create\n @mission_membership = MissionMembership.new(mission_membership_params)\n\n respond_to do |format|\n if @mission_membership.save\n format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully created.' }\n format.json { render :show, status: :created, location: @mission_membership }\n else\n format.html { render :new }\n format.json { render json: @mission_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @susu_memberships = SusuMembership.page(params[:page]).per(params[:per])\n\n render json: @susu_memberships\n end",
"def new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @membership }\n end\n end",
"def membership(user)\n memberships.find_by_user_id(user.id)\n end",
"def set_membership\n @membership = @organization.memberships.find(params[:id])\n end",
"def index\n @memberships = current_user.memberships.order('memberships.created_at DESC').limit(10)\n @memberships = @memberships.project_prefix(params[:query]) if params[:query].present?\n # as much as i'd love to add includes(:project), it breaks the join in project_prefix.\n # go ahead, try it and see.\n\n render json: decorate(@memberships)\n end",
"def show\n @membership = Membership.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @membership }\n end\n end",
"def get(incoming={})\n opts = HttpClient::Helper.symbolize_keys(incoming)\n query = {\n :org_guid => HttpClient::Preconditions.assert_class_or_nil('org_guid', HttpClient::Helper.to_uuid(opts.delete(:org_guid)), String),\n :org_key => HttpClient::Preconditions.assert_class_or_nil('org_key', opts.delete(:org_key), String),\n :user_guid => HttpClient::Preconditions.assert_class_or_nil('user_guid', HttpClient::Helper.to_uuid(opts.delete(:user_guid)), String),\n :role => HttpClient::Preconditions.assert_class_or_nil('role', opts.delete(:role), String),\n :limit => HttpClient::Preconditions.assert_class_or_nil('limit', opts.delete(:limit), Integer),\n :offset => HttpClient::Preconditions.assert_class_or_nil('offset', opts.delete(:offset), Integer)\n }.delete_if { |k, v| v.nil? }\n @client.request(\"/memberships\").with_query(query).get.map { |hash| Apidoc::Models::Membership.new(hash) }\n end",
"def show\n @membership ||= Membership.find(params[:id])\n @section = Section.find(params[:section_id])\n @attendancetypes = Attendancetype.getall\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @membership }\n end\n end",
"def index\n @memberships = @memberships.order(:site_id, :role_id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @memberships }\n end\n end",
"def index\n @membership_contributions = MembershipContribution.all\n end",
"def get_memberships\n return nil unless has_memberships?\n\n parent_css = \"div.profile-list > div:nth-of-type(#{@selector[:index] + 1})\"\n profile_css = @selector[:css]\n membership_css = 'div.dashboard-membership'\n new_selector = \"#{parent_css} #{profile_css} #{membership_css}\"\n\n (0..how_many_memberships? - 1).collect { |index| MemberManagement::Component::DashboardMembership.new(css: new_selector, index: index) }\n end",
"def get_mission_invites\n\t#get all missions of user with invitaion_status = pending\n user = User.exists? (params[:user_id])\n\tif user\n\t\tmissions = user.missions.references( :user_missions).select('missions.id, missions.title, user_missions.invitation_time').where( user_missions:{ invitation_status: PENDING_MESA_INVITATION})\n\t\trespond_to do |format|\n\t\t format.json {render :json=> {:mesa_invites=> missions, :status => true} }\n\t\tend\n else\n\t respond_to do |format|\n\t\t format.json {render :json=> {:error=>'No user exists with id' , :status => false} }\n\t end\n\tend\n end",
"def membership_path\n \"/memberships\"\n end",
"def party_memberships\n respond_to?(:partyHasPartyMembership) ? partyHasPartyMembership : []\n end",
"def index\n @students_project_memberships = StudentsProjectMembership.all\n end",
"def index\n @memberships = Membership.all\n @membership = Membership.new\n end",
"def index\n @team_memberships = current_user.team_memberships.where(status: 'pending')\n end",
"def index\n @missions = Mission.all\n end",
"def index\n @missions = Mission.all\n end",
"def index\n @missions = Mission.all\n end",
"def index\n @missions = Mission.all\n end",
"def show\n render json: @susu_membership\n end",
"def index\n respond_to do |format|\n format.json do\n @memberships = @project.memberships.order('created_at DESC').limit(10)\n @memberships = @memberships.user_prefix(params[:query]) if params[:query].present?\n\n render json: decorate(@memberships)\n end\n end\n end",
"def get_memberships_for_membership_id(membership_id)\n\t\t\t# If they didn't give us a membership_id to search, there's nothing we can do\n\t\t\treturn nil unless membership_id\n\n\t\t\t# Now that crossplay is in effect, we always want to specify \"all\" for the platform\n\t\t\tmembership_type_id = -1\n\n\t\t\turl = \"/User/GetMembershipsById/#{membership_id.to_s.uri_encode}/#{membership_type_id.to_s.uri_encode}/\"\n\n\t\t\tCowgod::Logger.log \"#{self.class}.#{__method__} - #{url}\"\n\n\t\t\tresponse = with_retry do\n\t\t\t\tself.class.get(url, @options)\n\t\t\tend\n\t\t\traise QueryError, 'API request failed' unless response && response.code == SUCCESS_CODE\n\n\t\t\tresponse.parsed_response&.dig('Response') || []\n\t\tend",
"def update\n respond_to do |format|\n if @mission_membership.update(mission_membership_params)\n format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission_membership }\n else\n format.html { render :edit }\n format.json { render json: @mission_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @tribal_memberships = TribalMembership.all\n end",
"def create\n @membership = Adhocracy::Membership.new(membership_params)\n\n if @membership.save\n render json: @membership, status: :created, location: api_v1_membership_path(@membership)\n else\n render_validation_errors @membership.errors\n end\n end",
"def create\n #sanity checks, can only modify memberships that you own\n if params[:user_id].to_i != current_user.id then\n render json: {message:'You do not own the membership list'}, :status => :unprocessable_entity\n return\n end\n\n #ensure the membership params is there\n unless params.has_key? :memberships then\n #render json: {message:'memberships list not found'}, :status => :unprocessable_entity\n #return\n #this could me no membership at all\n params[:memberships] = {}\n end\n\n #set the new memberships state\n current_user.set_memberships params[:memberships]\n\n render json: {\n message:'message received from server',\n memberships:User.find(params[:user_id]).memberships.map{ |x| x.attributes.merge({club_name: x.club_name})}\n }\n end",
"def show\n @loop_membership = LoopMembership.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @loop_membership }\n end\n end",
"def find_membership(organization_id, membership_id)\n http.get(\"#{membership_endpoint(organization_id)}/#{membership_id}\") do |response|\n Rexpense::Entities::Membership.new response.parsed_body\n end\n end",
"def index\n @memberships = Membership.where(user_id: current_user_id).includes(:project)\n project_array = []\n @memberships.each do |membership|\n project_array.push membership.project\n end\n json_response(project_array)\n end",
"def index\n @research_group_memberships = ResearchGroupMembership.all\n end",
"def CreateMembership params = {}\n \n APICall(path: 'group_memberships.json',method: 'POST',payload: params.to_json)\n \n end",
"def memberships options = {}\n request = if options.delete(:recursive) == false\n options[\"memberships\"] = true\n else\n options[\"all\"] = true\n end\n if filter = options.delete(:filter)\n filter = [filter] unless filter.is_a?(Array)\n options[\"filter\"] = filter.map(&Id.method(:new))\n end\n\n result = JSON.parse(rbac_role_resource[options_querystring options].get)\n if result.is_a?(Hash) && ( count = result['count'] )\n count\n else\n host = Conjur.configuration.core_url\n result.collect do |item|\n if item.is_a?(String)\n build_object(item, default_class: Role)\n else\n RoleGrant.parse_from_json(item, self.options)\n end\n end\n end\n end",
"def show\n authorize @organization_membership\n render json: @organization_membership\n end",
"def get_membership(group)\n @uri = URI.parse(\"#{@api_url}/group/#{group}/member\")\n body = make_get_request\n doc = Nokogiri::HTML(body)\n members = []\n doc.xpath('//a[@class=\"member\"]').each do |m|\n members << m.text\n end\n members\n end",
"def current_membership\n @current_membership\n end",
"def all_memberships\n Membership.all.select {|member_info| member_info.member_name == self}\n end",
"def get(incoming={})\n opts = HttpClient::Helper.symbolize_keys(incoming)\n query = {\n :org_guid => HttpClient::Preconditions.assert_class_or_nil('org_guid', HttpClient::Helper.to_uuid(opts.delete(:org_guid)), String),\n :org_key => HttpClient::Preconditions.assert_class_or_nil('org_key', opts.delete(:org_key), String),\n :user_guid => HttpClient::Preconditions.assert_class_or_nil('user_guid', HttpClient::Helper.to_uuid(opts.delete(:user_guid)), String),\n :role => HttpClient::Preconditions.assert_class_or_nil('role', opts.delete(:role), String),\n :limit => HttpClient::Preconditions.assert_class_or_nil('limit', opts.delete(:limit), Integer),\n :offset => HttpClient::Preconditions.assert_class_or_nil('offset', opts.delete(:offset), Integer)\n }.delete_if { |k, v| v.nil? }\n @client.request(\"/membership_requests\").with_query(query).get.map { |hash| Apidoc::Models::MembershipRequest.new(hash) }\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def index\n @groups = Group.where('owner_id' => current_user.id)\n @memberships = Membership.all\n respond_with(@groups, @memberships)\n end",
"def set_membership\n @membership = Membership.friendly.find(params[:id])\n end",
"def domain_memberships\n data[:domain_memberships]\n end",
"def domain_memberships\n data[:domain_memberships]\n end",
"def role_memberships\n if self.member?\n self.memberships\n else\n self.role_clubs.map{ |c| c.memberships }.flatten\n end\n end",
"def index\n @os_groups_memberships = OsGroupsMembership.all\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def index\n @company_profile = CompanyProfile.find(params[:company_profile_id])\n @company_profile_memberships = @company_profile.company_profile_membership\n \n end",
"def space_membership\n object.space_memberships.active.find_by(user: current_user)\n end",
"def new\n @membership = Membership.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @membership }\n end\n end",
"def index\n @member = Member.find(params[:member_id])\n\n @maritalinfos = @member.maritalinfo\n end",
"def new\n @membership = Membership.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @membership }\n end\n end",
"def show\n @organization_membershipship = current_person.organization_memberships.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @organization_membershipship }\n end\n end",
"def create\n @membership = Membership.new(params[:membership])\n @membership.member = current_member\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to sub_clubs_path, :notice => 'You requested membership.' }\n format.json { render :json => @membership, :status => :created, :location => @membership }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def get_members\n @user = User.find_by(user_params)\n @members = @user.members\n \n if not @members.nil?\n render json: @members\n else \n render json: \"\"\n end\n end",
"def memberships\n @basic_plan = Plan.find(1)\n @pro_plan = Plan.find(2)\n end",
"def member(id)\n space_memberships.find_by(user_id: id)\n end",
"def index\n groups = get_collection(assignment.groups) || return\n\n group_data = include_memberships(groups)\n\n respond_to do |format|\n format.xml do\n render xml: group_data.to_xml(root: 'groups', skip_types: 'true')\n end\n format.json { render json: group_data }\n end\n end",
"def create\n @membership = @member.memberships.build(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership.member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def members\n return @members if @members\n @members = Client.get(\"/organizations/#{id}/members/all\").json_into(Member)\n end",
"def test_should_join_a_group_as_user_via_API_JSON\r\n get \"/logout\"\r\n post \"/memberships.json\", :api_key => 'testapikey',\r\n :group_id => 1,\r\n :user_id => 3\r\n assert_response :created\r\n membership = JSON.parse(response.body)\r\n assert membership['user_id'] == 3, 'Incorrect user id'\r\n assert membership['group_id'] == 1, 'Incorrect group id'\r\n assert membership['role_id'].to_i == Role.find_by_rolename('user').id, 'Incorrect role id' \r\n end",
"def index\n @membership_options = MembershipOption.all\n end",
"def get_working_missions\n \t#get all missions of user with invitaion_status = pending and mission status = true\n user = User.exists?(params[:user_id])\n\tif user\n\t\tmissions = user.missions.references(:user_missions).select('missions.id, missions.title').where( user_missions:{ invitation_status: ACCEPTED_MESA_INVITATION}, missions: {is_authorized: true})\n\t\trespond_to do |format|\n\t\t format.json {render :json=> {:working_mesa=> missions, :status => true} }\n\t\tend\n else\n\t respond_to do |format|\n\t\t format.json {render :json=> {:error=>'No user exists with id' , :status => false} }\n\t end\n\tend\n end",
"def get_user_memberships_with_http_info(user_uuid, opts = {})\n\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: TeamsAPI.get_user_memberships ...'\n end\n # verify the required parameter 'user_uuid' is set\n if @api_client.config.client_side_validation && user_uuid.nil?\n fail ArgumentError, \"Missing the required parameter 'user_uuid' when calling TeamsAPI.get_user_memberships\"\n end\n # resource path\n local_var_path = '/api/v2/users/{user_uuid}/memberships'.sub('{user_uuid}', CGI.escape(user_uuid.to_s).gsub('%2F', '/'))\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] || 'UserTeamsResponse'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || [:apiKeyAuth, :appKeyAuth, :AuthZ]\n\n new_options = opts.merge(\n :operation => :get_user_memberships,\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 :api_version => \"V2\"\n )\n\n data, status_code, headers = @api_client.call_api(Net::HTTP::Get, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: TeamsAPI#get_user_memberships\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def show\n\t\t@membership = Membership.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tformat.html # show.html.erb\n\t\t\tformat.xml\t{ render :xml => @membership }\n\t\tend\n\tend",
"def index\n @mission_statuses = MissionStatus.all\n end",
"def show\n @user = current_user\n @user_groups = @user.groups\n\n @active_groups = []\n @pending_groups = []\n @pending_memberships = []\n @user.memberships.each do |m|\n if (m.status == \"active\")\n group = Group.find(m.group_id)\n @active_groups.push(group)\n elsif (m.status == \"pending\")\n group = Group.find(m.group_id)\n @pending_groups.push(group)\n @pending_memberships.push(m)\n end\n end\n end",
"def create\n @membership = Membership.new(params[:membership])\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render json: @membership, status: :created, location: @membership }\n else\n format.html { render action: \"new\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @members = User.with_membership(budget_domain_id: @budget_domain.id)\n end"
] |
[
"0.76106286",
"0.7396231",
"0.72806555",
"0.72588444",
"0.70949376",
"0.70320547",
"0.6945259",
"0.69267637",
"0.68940276",
"0.6810406",
"0.67558146",
"0.67558146",
"0.67558146",
"0.6728887",
"0.6690107",
"0.6661255",
"0.6593517",
"0.65318435",
"0.6506067",
"0.64345264",
"0.640314",
"0.6391935",
"0.639094",
"0.6368182",
"0.6328657",
"0.6312998",
"0.6301181",
"0.6300267",
"0.628454",
"0.62729645",
"0.6268393",
"0.6245253",
"0.6232004",
"0.6208084",
"0.61943054",
"0.6177275",
"0.6175798",
"0.6137547",
"0.6134988",
"0.61291754",
"0.6125356",
"0.6125356",
"0.6125356",
"0.6125356",
"0.61233217",
"0.61117494",
"0.61081207",
"0.6103276",
"0.6091456",
"0.60845274",
"0.60784143",
"0.6071285",
"0.60695744",
"0.6067874",
"0.60583556",
"0.6020827",
"0.601924",
"0.60062236",
"0.59989405",
"0.5991795",
"0.5955297",
"0.5947742",
"0.59435594",
"0.5942792",
"0.5940324",
"0.593627",
"0.593627",
"0.59139436",
"0.5893572",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5891897",
"0.5880186",
"0.5871322",
"0.587075",
"0.586885",
"0.5866306",
"0.5802085",
"0.57975006",
"0.5783148",
"0.5782754",
"0.57793385",
"0.57721925",
"0.57669604",
"0.5748031",
"0.5719133",
"0.5714216",
"0.5710175",
"0.5683909",
"0.5681847",
"0.56715846",
"0.56666845",
"0.56665003",
"0.5660067"
] |
0.78292584
|
0
|
GET /mission_memberships/1 GET /mission_memberships/1.json
|
def show
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def index\n @mission_memberships = MissionMembership.all\n end",
"def GetMembership id\n\n APICall(path: \"group_memberships/#{id}.json\")\n\n end",
"def set_mission_membership\n @mission_membership = MissionMembership.find(params[:id])\n end",
"def index\n @memberships = @user.memberships\n end",
"def memberships\n @list.client.get(\"#{url}/memberships\")\n end",
"def show\n @membership = Adhocracy::Membership.find(params[:id])\n\n render json: @membership\n end",
"def list_memberships(user)\n get(\"/#{user}/lists/memberships.json\")\n end",
"def GetMemberships params = {}\n\n params = params.merge(path: 'group_memberships.json')\n APICall(params)\n\n end",
"def index\n @memberships = @user.memberships\n\n respond_to do |format|\n format.html # index.rhtml\n end\n end",
"def index\n @memberships = @organization.memberships.all\n end",
"def index\n @memberships = @community.memberships\n end",
"def mission_membership_params\n params.require(:mission_membership).permit(:user_id, :mission_id)\n end",
"def show\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @membership }\n end\n end",
"def index\n @memberships = Membership.all\n end",
"def index\n @memberships = Membership.all\n end",
"def index\n @memberships = Membership.all\n end",
"def new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @membership }\n end\n end",
"def show\n @memberships = @participant.memberships.all\n end",
"def show\n @membership = Membership.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @membership }\n end\n end",
"def create\n @mission_membership = MissionMembership.new(mission_membership_params)\n\n respond_to do |format|\n if @mission_membership.save\n format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully created.' }\n format.json { render :show, status: :created, location: @mission_membership }\n else\n format.html { render :new }\n format.json { render json: @mission_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @organization_memberships = OrganizationMembership.where(user_id: params['user_id'])\n authorize @organization_memberships\n\n render json: @organization_memberships\n end",
"def index\n @user = User.find(params[:user_id])\n @lab_memberships = @user.lab_memberships\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @lab_memberships }\n end\n end",
"def set_membership\n @membership = @organization.memberships.find(params[:id])\n end",
"def show\n @loop_membership = LoopMembership.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @loop_membership }\n end\n end",
"def index\n authorize Group\n render :json => @group.group_memberships\n end",
"def show\n @membership ||= Membership.find(params[:id])\n @section = Section.find(params[:section_id])\n @attendancetypes = Attendancetype.getall\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @membership }\n end\n end",
"def update\n respond_to do |format|\n if @mission_membership.update(mission_membership_params)\n format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission_membership }\n else\n format.html { render :edit }\n format.json { render json: @mission_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def find_membership(organization_id, membership_id)\n http.get(\"#{membership_endpoint(organization_id)}/#{membership_id}\") do |response|\n Rexpense::Entities::Membership.new response.parsed_body\n end\n end",
"def membership(user)\n memberships.find_by_user_id(user.id)\n end",
"def new\n @membership = Membership.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @membership }\n end\n end",
"def new\n @membership = Membership.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @membership }\n end\n end",
"def get(incoming={})\n opts = HttpClient::Helper.symbolize_keys(incoming)\n query = {\n :org_guid => HttpClient::Preconditions.assert_class_or_nil('org_guid', HttpClient::Helper.to_uuid(opts.delete(:org_guid)), String),\n :org_key => HttpClient::Preconditions.assert_class_or_nil('org_key', opts.delete(:org_key), String),\n :user_guid => HttpClient::Preconditions.assert_class_or_nil('user_guid', HttpClient::Helper.to_uuid(opts.delete(:user_guid)), String),\n :role => HttpClient::Preconditions.assert_class_or_nil('role', opts.delete(:role), String),\n :limit => HttpClient::Preconditions.assert_class_or_nil('limit', opts.delete(:limit), Integer),\n :offset => HttpClient::Preconditions.assert_class_or_nil('offset', opts.delete(:offset), Integer)\n }.delete_if { |k, v| v.nil? }\n @client.request(\"/memberships\").with_query(query).get.map { |hash| Apidoc::Models::Membership.new(hash) }\n end",
"def current_membership\n @current_membership\n end",
"def index\n @susu_memberships = SusuMembership.page(params[:page]).per(params[:per])\n\n render json: @susu_memberships\n end",
"def show\n render json: @susu_membership\n end",
"def create\n @membership = Adhocracy::Membership.new(membership_params)\n\n if @membership.save\n render json: @membership, status: :created, location: api_v1_membership_path(@membership)\n else\n render_validation_errors @membership.errors\n end\n end",
"def index\n @memberships = current_user.memberships.order('memberships.created_at DESC').limit(10)\n @memberships = @memberships.project_prefix(params[:query]) if params[:query].present?\n # as much as i'd love to add includes(:project), it breaks the join in project_prefix.\n # go ahead, try it and see.\n\n render json: decorate(@memberships)\n end",
"def lms_membership\n unless current_organization.lti_configuration.supports_membership_service?\n lms_name = current_organization.lti_configuration.lms_name(default_name: \"your learning management system\")\n msg = \"GitHub Classroom does not have access to your course roster on #{lms_name}. Please ensure that\n you've allowed GitHub Classroom to retrieve your course membership from #{lms_name} and try again.\"\n\n raise LtiImportError, msg\n end\n\n membership_service = GitHubClassroom::LTI::MembershipService.new(\n current_organization.lti_configuration.context_membership_url,\n current_organization.lti_configuration.consumer_key,\n current_organization.lti_configuration.shared_secret,\n lti_version: current_organization.lti_configuration.lti_version\n )\n\n begin\n membership_service.students(body_params: current_organization.lti_configuration.context_membership_body_params)\n rescue Faraday::ClientError, JSON::ParserError => error\n report_error(error)\n\n lms_name = current_organization.lti_configuration.lms_name(default_name: \"your learning management system\")\n msg = \"GitHub Classroom is unable to fetch membership from #{lms_name} at this time. If the problem persists,\n re-launch GitHub Classroom from your learning management system and try again.\"\n\n raise LtiImportError, msg\n end\n end",
"def index\n @memberships = Membership.all\n @membership = Membership.new\n end",
"def index\n @memberships = @memberships.order(:site_id, :role_id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @memberships }\n end\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.friendly.find(params[:id])\n end",
"def get_mission_invites\n\t#get all missions of user with invitaion_status = pending\n user = User.exists? (params[:user_id])\n\tif user\n\t\tmissions = user.missions.references( :user_missions).select('missions.id, missions.title, user_missions.invitation_time').where( user_missions:{ invitation_status: PENDING_MESA_INVITATION})\n\t\trespond_to do |format|\n\t\t format.json {render :json=> {:mesa_invites=> missions, :status => true} }\n\t\tend\n else\n\t respond_to do |format|\n\t\t format.json {render :json=> {:error=>'No user exists with id' , :status => false} }\n\t end\n\tend\n end",
"def memberships\n prefix = \"#{path_prefix}/memberships\"\n Ghee::API::Users::Memberships::Proxy.new(connection, prefix)\n end",
"def index\n respond_to do |format|\n format.json do\n @memberships = @project.memberships.order('created_at DESC').limit(10)\n @memberships = @memberships.user_prefix(params[:query]) if params[:query].present?\n\n render json: decorate(@memberships)\n end\n end\n end",
"def index\n @membership_contributions = MembershipContribution.all\n end",
"def show\n authorize @organization_membership\n render json: @organization_membership\n end",
"def index\n @missions = Mission.all\n end",
"def index\n @missions = Mission.all\n end",
"def index\n @missions = Mission.all\n end",
"def index\n @missions = Mission.all\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def list_memberships(user_id:)\n path = '/users/{userId}/memberships'\n .gsub('{userId}', user_id)\n\n if user_id.nil?\n raise Appwrite::Exception.new('Missing required parameter: \"userId\"')\n end\n\n params = {\n }\n \n headers = {\n \"content-type\": 'application/json',\n }\n\n @client.call(\n method: 'GET',\n path: path,\n headers: headers,\n params: params,\n response_type: Models::MembershipList\n )\n end",
"def membership_path\n \"/memberships\"\n end",
"def show\n @organization_membershipship = current_person.organization_memberships.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @organization_membershipship }\n end\n end",
"def index\n @memberships = Membership.where(user_id: current_user_id).includes(:project)\n project_array = []\n @memberships.each do |membership|\n project_array.push membership.project\n end\n json_response(project_array)\n end",
"def index\n @team_memberships = current_user.team_memberships.where(status: 'pending')\n end",
"def member(id)\n space_memberships.find_by(user_id: id)\n end",
"def create\n #sanity checks, can only modify memberships that you own\n if params[:user_id].to_i != current_user.id then\n render json: {message:'You do not own the membership list'}, :status => :unprocessable_entity\n return\n end\n\n #ensure the membership params is there\n unless params.has_key? :memberships then\n #render json: {message:'memberships list not found'}, :status => :unprocessable_entity\n #return\n #this could me no membership at all\n params[:memberships] = {}\n end\n\n #set the new memberships state\n current_user.set_memberships params[:memberships]\n\n render json: {\n message:'message received from server',\n memberships:User.find(params[:user_id]).memberships.map{ |x| x.attributes.merge({club_name: x.club_name})}\n }\n end",
"def get_memberships\n return nil unless has_memberships?\n\n parent_css = \"div.profile-list > div:nth-of-type(#{@selector[:index] + 1})\"\n profile_css = @selector[:css]\n membership_css = 'div.dashboard-membership'\n new_selector = \"#{parent_css} #{profile_css} #{membership_css}\"\n\n (0..how_many_memberships? - 1).collect { |index| MemberManagement::Component::DashboardMembership.new(css: new_selector, index: index) }\n end",
"def show\n\t\t@membership = Membership.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tformat.html # show.html.erb\n\t\t\tformat.xml\t{ render :xml => @membership }\n\t\tend\n\tend",
"def index\n @member = Member.find(params[:member_id])\n\n @maritalinfos = @member.maritalinfo\n end",
"def get_membership(type)\n memberships = get_memberships\n memberships.each do |membership|\n return membership if membership.type == type\n end\n raise StandardError.new \"Membership type #{type} not found for member #{name}\"\n end",
"def index\n @students_project_memberships = StudentsProjectMembership.all\n end",
"def show\n @mission = Mission.find(params[:id])\n end",
"def get(incoming={})\n opts = HttpClient::Helper.symbolize_keys(incoming)\n query = {\n :org_guid => HttpClient::Preconditions.assert_class_or_nil('org_guid', HttpClient::Helper.to_uuid(opts.delete(:org_guid)), String),\n :org_key => HttpClient::Preconditions.assert_class_or_nil('org_key', opts.delete(:org_key), String),\n :user_guid => HttpClient::Preconditions.assert_class_or_nil('user_guid', HttpClient::Helper.to_uuid(opts.delete(:user_guid)), String),\n :role => HttpClient::Preconditions.assert_class_or_nil('role', opts.delete(:role), String),\n :limit => HttpClient::Preconditions.assert_class_or_nil('limit', opts.delete(:limit), Integer),\n :offset => HttpClient::Preconditions.assert_class_or_nil('offset', opts.delete(:offset), Integer)\n }.delete_if { |k, v| v.nil? }\n @client.request(\"/membership_requests\").with_query(query).get.map { |hash| Apidoc::Models::MembershipRequest.new(hash) }\n end",
"def create\n @membership = Membership.new(params[:membership])\n @membership.member = current_member\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to sub_clubs_path, :notice => 'You requested membership.' }\n format.json { render :json => @membership, :status => :created, :location => @membership }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def index\n @tribal_memberships = TribalMembership.all\n end",
"def get_memberships_for_membership_id(membership_id)\n\t\t\t# If they didn't give us a membership_id to search, there's nothing we can do\n\t\t\treturn nil unless membership_id\n\n\t\t\t# Now that crossplay is in effect, we always want to specify \"all\" for the platform\n\t\t\tmembership_type_id = -1\n\n\t\t\turl = \"/User/GetMembershipsById/#{membership_id.to_s.uri_encode}/#{membership_type_id.to_s.uri_encode}/\"\n\n\t\t\tCowgod::Logger.log \"#{self.class}.#{__method__} - #{url}\"\n\n\t\t\tresponse = with_retry do\n\t\t\t\tself.class.get(url, @options)\n\t\t\tend\n\t\t\traise QueryError, 'API request failed' unless response && response.code == SUCCESS_CODE\n\n\t\t\tresponse.parsed_response&.dig('Response') || []\n\t\tend",
"def show\n @mission = Mission.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @mission }\n end\n end",
"def create\n @membership = @member.memberships.build(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership.member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @mission = Mission.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @mission }\n end\n end",
"def index\n @research_group_memberships = ResearchGroupMembership.all\n end",
"def show\n @mission = Mission.find(params[:id])\n end",
"def create\n @membership = Membership.new(params[:membership])\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render json: @membership, status: :created, location: @membership }\n else\n format.html { render action: \"new\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def get_membership(group)\n @uri = URI.parse(\"#{@api_url}/group/#{group}/member\")\n body = make_get_request\n doc = Nokogiri::HTML(body)\n members = []\n doc.xpath('//a[@class=\"member\"]').each do |m|\n members << m.text\n end\n members\n end",
"def welcome\n @membership = Membership.find(params['subscription_id'])\n end",
"def new\n @user = User.new\n @user.pending_memberships.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @user }\n end\n end",
"def index\n @company_profile = CompanyProfile.find(params[:company_profile_id])\n @company_profile_memberships = @company_profile.company_profile_membership\n \n end",
"def CreateMembership params = {}\n \n APICall(path: 'group_memberships.json',method: 'POST',payload: params.to_json)\n \n end",
"def create\n @membership = @organization.memberships.build(membership_params.merge(creator: authed_user))\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def space_membership\n object.space_memberships.active.find_by(user: current_user)\n end",
"def create\n if params[:membership][:user_username]\n params[:membership][:user_id] = User.find_by_username(params[:membership].delete('user_username')).try!(:id)\n end\n\n @membership = @project.memberships.create(membership_params)\n respond_with @project, @membership\n end",
"def test_should_join_a_group_as_user_via_API_JSON\r\n get \"/logout\"\r\n post \"/memberships.json\", :api_key => 'testapikey',\r\n :group_id => 1,\r\n :user_id => 3\r\n assert_response :created\r\n membership = JSON.parse(response.body)\r\n assert membership['user_id'] == 3, 'Incorrect user id'\r\n assert membership['group_id'] == 1, 'Incorrect group id'\r\n assert membership['role_id'].to_i == Role.find_by_rolename('user').id, 'Incorrect role id' \r\n end",
"def new\n\t\t@membership = Membership.new\n\t\t@membership.members.build\n\n\t\trespond_to do |format|\n\t\t\tformat.html # new.html.erb\n\t\t\tformat.xml\t{ render :xml => @membership }\n\t\tend\n\tend",
"def create\n @membership = Membership.new(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to community_memberships_path(@community), notice: 'Community membership was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n\n @membership = Membership.new\n\n end",
"def show\n @membership = Membership.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @membership }\n end\n end",
"def set_mission\n @mission = Mission.find(params[:id])\n end",
"def destroy\n @mission_membership.destroy\n respond_to do |format|\n format.html { redirect_to mission_memberships_url, notice: 'Mission membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def create\n\t\t@membership = Membership.new(params[:membership])\n\n\t\trespond_to do |format|\n\t\t\tif @membership.save\n\t\t\t\tformat.html { redirect_to(@membership, :notice => 'Membership was successfully created.') }\n\t\t\t\tformat.xml\t{ render :xml => @membership, :status => :created, :location => @membership }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"new\" }\n\t\t\t\tformat.xml\t{ render :xml => @membership.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def party_memberships\n respond_to?(:partyHasPartyMembership) ? partyHasPartyMembership : []\n end",
"def new\n\t\t@member = Member.new(:membership_id => params[:membership_id])\n\n\t\trespond_to do |format|\n\t\t\tformat.html # new.html.erb\n\t\t\tformat.xml\t{ render :xml => @member }\n\t\tend\n\tend"
] |
[
"0.7767887",
"0.7276003",
"0.7273928",
"0.7247106",
"0.7180575",
"0.7057984",
"0.6946464",
"0.69091326",
"0.6858061",
"0.6809658",
"0.67634076",
"0.6693454",
"0.6691555",
"0.6681637",
"0.6681637",
"0.6681637",
"0.6678518",
"0.6674249",
"0.6662902",
"0.66340756",
"0.65968674",
"0.65470374",
"0.64764583",
"0.6433369",
"0.6417709",
"0.64059013",
"0.6358646",
"0.6348775",
"0.63410693",
"0.6332126",
"0.63262343",
"0.6319687",
"0.62867266",
"0.62834793",
"0.62822014",
"0.62606424",
"0.6260202",
"0.6259829",
"0.62463653",
"0.6214247",
"0.61947125",
"0.6184432",
"0.6150607",
"0.6144214",
"0.6135581",
"0.6134455",
"0.61332345",
"0.6129129",
"0.6129129",
"0.6129129",
"0.6129129",
"0.61234814",
"0.61234814",
"0.61234814",
"0.61234814",
"0.61234814",
"0.61234814",
"0.61234814",
"0.61234814",
"0.61234814",
"0.6107797",
"0.60996586",
"0.60947794",
"0.6068023",
"0.6032764",
"0.60327196",
"0.60208696",
"0.60177815",
"0.6016181",
"0.6008299",
"0.6003668",
"0.600262",
"0.6001142",
"0.5996823",
"0.59895945",
"0.5987291",
"0.59843624",
"0.5984246",
"0.5977593",
"0.5944306",
"0.5940673",
"0.59275705",
"0.59157616",
"0.5901841",
"0.58962214",
"0.5893917",
"0.58889186",
"0.58559394",
"0.5854978",
"0.5850907",
"0.583095",
"0.58245957",
"0.581944",
"0.5816388",
"0.58140844",
"0.5811114",
"0.5793559",
"0.57812035",
"0.5766535",
"0.575806",
"0.5752813"
] |
0.0
|
-1
|
POST /mission_memberships POST /mission_memberships.json
|
def create
@mission_membership = MissionMembership.new(mission_membership_params)
respond_to do |format|
if @mission_membership.save
format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully created.' }
format.json { render :show, status: :created, location: @mission_membership }
else
format.html { render :new }
format.json { render json: @mission_membership.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def CreateMembership params = {}\n \n APICall(path: 'group_memberships.json',method: 'POST',payload: params.to_json)\n \n end",
"def mission_membership_params\n params.require(:mission_membership).permit(:user_id, :mission_id)\n end",
"def create\n @membership = Adhocracy::Membership.new(membership_params)\n\n if @membership.save\n render json: @membership, status: :created, location: api_v1_membership_path(@membership)\n else\n render_validation_errors @membership.errors\n end\n end",
"def create\n #sanity checks, can only modify memberships that you own\n if params[:user_id].to_i != current_user.id then\n render json: {message:'You do not own the membership list'}, :status => :unprocessable_entity\n return\n end\n\n #ensure the membership params is there\n unless params.has_key? :memberships then\n #render json: {message:'memberships list not found'}, :status => :unprocessable_entity\n #return\n #this could me no membership at all\n params[:memberships] = {}\n end\n\n #set the new memberships state\n current_user.set_memberships params[:memberships]\n\n render json: {\n message:'message received from server',\n memberships:User.find(params[:user_id]).memberships.map{ |x| x.attributes.merge({club_name: x.club_name})}\n }\n end",
"def create\n @membership = @member.memberships.build(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership.member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_mission_membership\n @mission_membership = MissionMembership.find(params[:id])\n end",
"def create\n @membership = Membership.new(params[:membership])\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render json: @membership, status: :created, location: @membership }\n else\n format.html { render action: \"new\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = Membership.new(params[:membership])\n @membership.member = current_member\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to sub_clubs_path, :notice => 'You requested membership.' }\n format.json { render :json => @membership, :status => :created, :location => @membership }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = Membership.new(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to community_memberships_path(@community), notice: 'Community membership was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @mission_memberships = MissionMembership.all\n end",
"def create\n @membership = Membership.new(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: \"Membership was successfully created.\" }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = @organization.memberships.build(membership_params.merge(creator: authed_user))\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n if params[:membership][:user_username]\n params[:membership][:user_id] = User.find_by_username(params[:membership].delete('user_username')).try!(:id)\n end\n\n @membership = @project.memberships.create(membership_params)\n respond_with @project, @membership\n end",
"def create\n @organization_membership = OrganizationMembership.new(organization_membership_create_params)\n # authorize @organization_membership\n\n if @organization_membership.save\n render json: @organization_membership, status: :created, location: nil\n else\n render json: @organization_membership.errors, status: :unprocessable_entity\n end\n end",
"def create\n @membership = Membership.new(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to groups_path, notice: 'User was successfully added to group.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\t\t@membership = Membership.new(params[:membership])\n\n\t\trespond_to do |format|\n\t\t\tif @membership.save\n\t\t\t\tformat.html { redirect_to(@membership, :notice => 'Membership was successfully created.') }\n\t\t\t\tformat.xml\t{ render :xml => @membership, :status => :created, :location => @membership }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"new\" }\n\t\t\t\tformat.xml\t{ render :xml => @membership.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def create\n @membership = @website.memberships.new(membership_params)\n @membership.user.no_password = true\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render action: 'show', status: :created, location: @membership }\n else\n format.html { render action: 'new' }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @team_membership = TeamMembership.new(team_membership_params)\n\n respond_to do |format|\n if @team_membership.save\n format.html { redirect_to @team_membership, notice: 'Team membership was successfully created.' }\n format.json { render :show, status: :created, location: @team_membership }\n else\n format.html { render :new }\n format.json { render json: @team_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n \n @mission = Mission.new(mission_params)\n \n #assign users to mission\n if params[:user_ids].present?\n user = params[:user_ids].delete_if{ |x| x.empty? }\n @mission.users << User.find(params[:user_ids]) \n end\n \n \n respond_to do |format|\n if @mission.save\n format.html { redirect_to [:admin, @mission], notice: 'Mission was successfully created.' }\n format.json { render action: 'show', status: :created, location: @mission }\n else\n format.html { render action: 'new' }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = Membership.new(params[:membership])\n @membership.user_id = current_user.id\n if @membership.save\n end\n end",
"def membership_params\n params.require(:membership).permit(:student_id, :group_id)\n end",
"def index\n @memberships = @user.memberships\n end",
"def post(hash)\n HttpClient::Preconditions.assert_class('hash', hash, Hash)\n @client.request(\"/membership_requests\").with_json(hash.to_json).post { |hash| Apidoc::Models::MembershipRequest.new(hash) }\n end",
"def add_team_memberships\n this_season_key, school_year_text = TeamMembership.this_season_and_year(time_now: time_now)\n TeamMembership.create!({\n student_id: shs_freshman_mari.id,\n activity_text: 'Competitive Cheerleading Varsity',\n coach_text: 'Fatima Teacher',\n season_key: this_season_key,\n school_year_text: school_year_text\n })\n TeamMembership.create!({\n student_id: shs_senior_kylo.id,\n activity_text: 'Cross Country - Boys Varsity',\n coach_text: 'Jonathan Fishman',\n season_key: this_season_key,\n school_year_text: school_year_text\n })\n end",
"def create\n @lab_membership = LabMembership.new(params[:lab_membership])\n @user = @lab_membership.user\n\n respond_to do |format|\n if @lab_membership.save\n flash[:notice] = 'LabMembership was successfully created.'\n format.html { redirect_to( user_lab_memberships_path(@user) ) }\n format.xml { render :xml => @lab_membership, :status => :created, :location => @lab_membership }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @lab_membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @mission_membership.update(mission_membership_params)\n format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission_membership }\n else\n format.html { render :edit }\n format.json { render json: @mission_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_team_member\n clinics = params[:clinics].split(\", \")\n\n team_member = TeamMember.create(\n email: params[:email],\n first_name: params[:first_name],\n last_name: params[:last_name],\n user: params[:user],\n status: \"Active\",\n role: params[:role]\n )\n\n clinics.each do |clinic|\n Clinic.find(clinic).team_members << team_member\n end\n\n render json: team_member, include: ['clinics']\n end",
"def memberships\n @list.client.get(\"#{url}/memberships\")\n end",
"def create_membership(organization_id, params)\n http.post(membership_endpoint(organization_id), body: params) do |response|\n response.parsed_body\n end\n end",
"def create\n @students_project_membership = StudentsProjectMembership.new(students_project_membership_params)\n\n respond_to do |format|\n if @students_project_membership.save\n format.html { redirect_to @students_project_membership, notice: 'Students project membership was successfully created.' }\n format.json { render :show, status: :created, location: @students_project_membership }\n else\n format.html { render :new }\n format.json { render json: @students_project_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def test_should_join_a_group_as_user_via_API_JSON\r\n get \"/logout\"\r\n post \"/memberships.json\", :api_key => 'testapikey',\r\n :group_id => 1,\r\n :user_id => 3\r\n assert_response :created\r\n membership = JSON.parse(response.body)\r\n assert membership['user_id'] == 3, 'Incorrect user id'\r\n assert membership['group_id'] == 1, 'Incorrect group id'\r\n assert membership['role_id'].to_i == Role.find_by_rolename('user').id, 'Incorrect role id' \r\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :group_id, :email, :title)\n end",
"def create_membership_request\n member = Member.new(squad: @squad, user: current_user, membership: 'request')\n member.save(validate: false)\n end",
"def new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @membership }\n end\n end",
"def create\n # TODO: test if \"user_established_at\" and \"network_established_at\" can be hacked (ie: set) through API calls,\n # thereby creating memberships that are already 'accepted' at creation.\n user = User.find_by_id(params[:membership][:user_id])\n if user.nil?\n render_404(\"User not found.\")\n elsif !Membership.find_by_user_id_and_network_id(params[:membership][:user_id], params[:membership][:network_id]) ||\n Network.find(params[:membership][:network_id]).owner?(user)\n\n @membership = Membership.new(params[:membership])\n\n @membership.user_established_at = nil\n @membership.network_established_at = nil\n if @membership.message.blank?\n @membership.message = nil\n end\n \n respond_to do |format|\n\n if @membership.save\n # Take into account network's new member policy setting\n if (@membership.network.open?)\n @membership.accept!\n \n begin\n user = @membership.user\n network = @membership.network\n Notifier.deliver_auto_join_group(user, network, base_host) if network.administrators(true).any? {|a| a.send_notifications?}\n rescue\n logger.error(\"ERROR: failed to send email notification for auto join group. Membership ID: #{@membership.id}\")\n end\n \n flash[:notice] = 'You have successfully joined the Group.'\n elsif (@membership.network.membership_by_request?)\n @membership.user_establish!\n \n begin\n user = @membership.user\n network = @membership.network\n Notifier.deliver_membership_request(user, network, @membership, base_host) if network.administrators(true).any? {|a| a.send_notifications?}\n rescue Exception => e\n logger.error(\"ERROR: failed to send Membership Request email notification. Membership ID: #{@membership.id}\")\n logger.error(\"EXCEPTION:\" + e)\n end\n \n flash[:notice] = 'Membership was successfully requested.'\n end\n\n format.html { redirect_to user_membership_path(current_user.id, @membership) }\n else\n format.html { render :action => \"new\" }\n end\n end\n else\n respond_to do |format|\n flash[:error] = \"Membership not created (already exists)\"\n format.html { render :action => \"new\" }\n end\n end\n end",
"def membership_params\n params.require(:membership).permit(:user_via_email, :privileges)\n end",
"def membership_params\n params.require(:membership).permit(:creator_id, :user_id, :belongable_id, :belongable_type, :scope, :state)\n end",
"def membership_params\n params.require(:membership).permit(:type, :start_date, :end_date, :membership_type, :payment_type, :notes,\n :plan_id, :plan_category_id, :paid_by, :average_monthly_payment, :trial_period_days, member_attributes: [:id, :first_name, :last_name])\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :school_id, :primary_role, :school_name,\n :user_name, :slug,\n { details: [:date_enrolled, :date_completed, :current_grades, :other_roles] })\n end",
"def create\n @os_groups_membership = OsGroupsMembership.new(os_groups_membership_params)\n\n respond_to do |format|\n if @os_groups_membership.save\n format.html { redirect_to @os_groups_membership, notice: 'Os groups membership was successfully created.' }\n format.json { render :show, status: :created, location: @os_groups_membership }\n else\n format.html { render :new }\n format.json { render json: @os_groups_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new_membership_params\n params.require(:membership).permit(:conversation_id, :user_id)\n end",
"def create\n if current_user.tribal_membership.nil?\n @tribal_membership = TribalMembership.create(tribe_id:params[:tribe_id], user_id:current_user.id)\n else\n @tribal_membership = current_user.tribal_membership\n @tribal_membership.update(tribal_membership_params)\n end\n\n respond_to do |format|\n if @tribal_membership.save\n format.html { redirect_to contrib_campsites_path, notice: 'Tribal membership was successfully created.' }\n format.json { render action: 'show', status: :created, location: @tribal_membership }\n else\n format.html { redirect_to new_tribal_membership_path }\n format.json { render json: @tribal_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def test_should_join_a_group_as_admin_via_API_JSON\r\n get \"/logout\"\r\n post \"/memberships.json\", :api_key => 'testapikey',\r\n :group_id => 1,\r\n :user_id => 1\r\n assert_response :created\r\n membership = JSON.parse(response.body)\r\n assert membership['user_id'] == 1, 'Incorrect user id'\r\n assert membership['group_id'] == 1, 'Incorrect group id'\r\n assert membership['role_id'].to_i == Role.find_by_rolename('group_admin').id, 'Incorrect role id' \r\n end",
"def new\n @user = User.new\n @user.pending_memberships.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @user }\n end\n end",
"def UpdateMembership params = {}\n \n APICall(path: 'group_memberships.json',method: 'PUT',payload: params.to_json)\n \n end",
"def create_members\n project = Project.find(params[:id])\n\n params[:members].each do |member_id|\n user = User.find(member_id)\n project.users << user unless project.users.include?(user) \n end\n \n respond_to do |format|\n format.html { redirect_to project_path(@project), notice: 'members were successfully added.' }\n format.json { render json: @project, status: :created, location: @project }\n end\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :valid_from, :duration, :purchase_date, :cancellation_date, :refund, :price_paid)\n end",
"def membership_params\n params.require(:membership).permit(:admin)\n end",
"def create\n @membership = Membership.new(membership_params)\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership.school, notice: 'School Account was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n group_id = params[:group_id]\n user = User.find(params[:user_id])\n group = Group.find_by_id(group_id)\n if user.is_admin || group.creator == current_user\n role = Role.find_by_rolename('group_admin')\n else\n role = Role.find_by_rolename('user')\n end\n \n is_authorized = false\n\n if group.private\n if user.is_admin || group.creator == current_user\n is_authorized = true\n end\n else\n is_authorized = true\n end \n\n @membership = Membership.create({:group_id => params[:group_id], \n :user_id => user.id,\n :role_id => role.id,\n :authorized => is_authorized})\n if @membership.save\n respond_to do |format|\n format.html { redirect_to group_path(group_id) }\n format.xml { render :xml => @membership, :status => :created } \n format.json { render :json => @membership, :status => :created } \n end\n else\n respond_to do |format|\n format.html { redirect_to group_path(group_id) }\n format.xml { render :xml => @membership.errors, :status => :unprocessable_entity }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_membership\n @membership = @organization.memberships.find(params[:id])\n end",
"def create\n\n @tea_club = TeaClub.new(tea_club_params)\n\n respond_to do |format|\n\n if @tea_club.save\n\n membership = Membership.new(:tea_club_id => @tea_club.id, :confirmed => true)\n current_user.memberships << membership\n membership.save\n\n format.html { redirect_to @tea_club, notice: 'Tea club was successfully created.' }\n format.json { render action: 'show', status: :created, location: @tea_club }\n\n else\n format.html { render action: 'new' }\n format.json { render json: @tea_club.errors, status: :unprocessable_entity }\n end\n\n end\n end",
"def create\n @user = GetUserInfo.run(membership_params)\n if @user == :no_github_user\n session[:new_member_msg] = :no_github_user\n session[:new_member_id] = membership_params['nickname']\n redirect_to class_group_memberships_url\n return\n end\n if membership_params['teacher'] == 'on'\n kind = 'teacher'\n else \n kind = 'student'\n end\n @membership = Membership.new(\n user_id: @user.id,\n kind: kind,\n class_group_id: @class_group.id)\n respond_to do |format|\n if @membership.save\n session[:new_member_msg] = :successful_save\n session[:new_member_id] = @user.id\n format.html { redirect_to class_group_memberships_url, notice: 'Membership was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n \n @membership_record = MembershipRecord.new(membership_record_params)\n\n respond_to do |format|\n if @membership_record.save\n format.html { redirect_to @membership_record, notice: 'Membership record was successfully created.' }\n format.json { render :show, status: :created, location: @membership_record }\n else\n format.html { render :new }\n format.json { render json: @membership_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def GetMemberships params = {}\n\n params = params.merge(path: 'group_memberships.json')\n APICall(params)\n\n end",
"def membership_params\n params.require(:membership).permit( :group_id, :user_id)\n end",
"def create\n @research_group_membership = ResearchGroupMembership.new(research_group_membership_params)\n\n respond_to do |format|\n if @research_group_membership.save\n format.html { redirect_to @research_group_membership, notice: 'Research group membership was successfully created.' }\n format.json { render action: 'show', status: :created, location: @research_group_membership }\n else\n format.html { render action: 'new' }\n format.json { render json: @research_group_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @project = current_user.projects.build(project_params)\n @project.memberships.new(user: current_user,role:'Creator')\n respond_to do |format|\n if @project.save\n format.html { redirect_to @project, notice: 'Project was successfully created.' }\n format.json { render :show, status: :created, location: @project }\n else\n format.html { render :new }\n format.json { render json: @project.errors, status: :unprocessable_entity }\n end\n end\n end",
"def membership_params\n params.require(:membership).permit(:gym_id, :client_id, :charge)\n end",
"def create\n\n @pending_membership = PendingMembership.new(club_id: params[:user][:pending_membership][:club_id])\n\n params[:user].delete(\"pending_membership\")\n\n @user = User.new(params[:user])\n @possible_memberships = PendingMembership.where(user_email: @user.email)\n\n if @possible_memberships.length > 0 && @user.save\n new_user = User.last\n @membership = Membership.new\n @membership.user_id = new_user.id\n @membership.club_id = @possible_memberships.first.club_id\n @possible_memberships.first.destroy\n @membership.save\n session[:user_id] = @user.id\n redirect_to @user, notice: 'Account and membership successfuly created.'\n elsif @user.save\n @pending_membership.user_id = @user.id \n @pending_membership.user_first_name = @user.first_name\n @pending_membership.user_last_name = @user.last_name\n @pending_membership.user_email = @user.email\n @pending_membership.save\n UserMailer.admin_verification(@pending_membership).deliver\n UserMailer.welcome(@user).deliver\n session[:user_id] = @user.id\n redirect_to @user, notice: 'Account successfuly created.' \n else\n # needed for render 'new' in case of form errors \n @user.pending_memberships.build\n render action: \"new\"\n end\n end",
"def create\n valid = true\n render :update do |page|\n if request.xhr?\n currently_membership_name = []\n params[:membership].each do |key, value|\n if params[:membership][key.to_s][:to_present].eql?(\"1\")\n current_date = Time.now\n params[:membership][key.to_s][\"until_date(1i)\"] = params[:membership][key.to_s][:until_year] = current_date.strftime(\"%Y\")\n params[:membership][key.to_s][\"until_date(2i)\"] = current_date.strftime(\"%m\")\n else\n params[:membership][key.to_s][\"until_date(1i)\"] = params[:membership][key.to_s][:until_year]\n end\n params[:membership][key.to_s][\"from_date(1i)\"] = params[:membership][key.to_s][:from_year]\n params[:membership][key.to_s][\"from_date(3i)\"] = \"1\"\n params[:membership][key.to_s][\"until_date(3i)\"] = \"1\"\n @membership = Membership.new(params[:membership][key.to_s])\n @membership.user_id = current_user.id\n unless @membership.valid?\n valid = false\n if @membership.errors.to_a.map{|err| err[0]}.include?(\"name\")\n page << \"$('membership_name_must_unique_#{key}').show()\"\n page << \"$('membership_name_cant_be_blank_#{key}').hide()\"\n elsif @membership.errors.to_a.map{|err| err[0]}.include?(\"until_date\")\n page << \"$('membership_end_year_must_greater_than_start_year_#{key}').show()\"\n end\n else\n if currently_membership_name.include?(params[:membership][key.to_s][:name])\n valid = false\n page << \"$('membership_name_must_unique_#{key}').show()\"\n page << \"$('membership_name_cant_be_blank_#{key}').hide()\"\n else\n page << \"$('membership_name_must_unique_#{key}').hide()\"\n page << \"$('membership_name_cant_be_blank_#{key}').hide()\"\n end\n currently_membership_name << params[:membership][key.to_s][:name]\n end\n end\n end\n\n if valid\n params[:membership].each do |key, value|\n @memberships = []\n if params[:membership][key.to_s][:to_present].eql?(\"1\")\n current_date = Time.now\n params[:membership][key.to_s][\"until_date(1i)\"] = params[:membership][key.to_s][:until_year] = current_date.strftime(\"%Y\")\n params[:membership][key.to_s][\"until_date(2i)\"] = current_date.strftime(\"%m\")\n else\n params[:membership][key.to_s][\"until_date(1i)\"] = params[:membership][key.to_s][:until_year]\n end\n params[:membership][key.to_s][\"from_date(1i)\"] = params[:membership][key.to_s][:from_year]\n params[:membership][key.to_s][\"from_date(3i)\"] = \"1\"\n params[:membership][key.to_s][\"until_date(3i)\"] = \"1\"\n @membership = Membership.new(params[:membership][key.to_s])\n @membership.user_id = current_user.id\n\n @membership.save\n if request.xhr?\n @memberships << @membership\n page.insert_html :top, \"membership_index_container\", :partial => \"index\"\n page << \"$(\\\"add_membership_form\\\").innerHTML = \\\"\\\"\"\n end\n end\n end\n end\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :year, :type, :stripe_card_token, :subscribe, privileges: [], membership: %i[info]).tap do |allowlisted|\n allowlisted[:info] = params[:membership][:info]\n end\n end",
"def ayty_replicate_memberships\n # usuario que sera atualizado\n @user = User.find(params[:id])\n\n @user.ayty_replicate_memberships_by_user_id(params[:ayty_user_stunt_id])\n\n @principal = Principal.find(@user.id)\n\n respond_to do |format|\n format.html { redirect_to edit_polymorphic_path(principal, :tab => 'memberships') }\n format.js\n end\n end",
"def index\n @memberships = @community.memberships\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :beer_club_id)\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def create_membership\n member = Member.new(squad: @squad, user: current_user, membership: 'owner')\n member.save(validate: false)\n end",
"def membership_params\n params.require(:membership).permit(:is_admin, :remote_uid)\n end",
"def membership_params\n params.require(:membership).permit(:is_admin, :remote_uid)\n end",
"def index\n @memberships = Membership.all\n @membership = Membership.new\n end",
"def membership_params\n params.require(:membership).permit(:beer_club_id, :user_id)\n end",
"def new\n @membership = Membership.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @membership }\n end\n end",
"def create\n @enrollment = @membership.build_enrollment(params[:enrollment])\n\n respond_to do |format|\n if @enrollment.save\n format.html { redirect_to business_membership_enrollment_path(@business, @membership, @enrollment), notice: 'Enrollment was successfully created.' }\n else\n format.html { render action: \"new\" }\n end\n end\n end",
"def new\n @membership = Membership.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @membership }\n end\n end",
"def create\n @department_entry_membership = DepartmentEntryMembership.new(department_entry_membership_params)\n\n respond_to do |format|\n if @department_entry_membership.save\n format.html { redirect_to @department_entry_membership, notice: 'Department entry membership was successfully created.' }\n format.json { render :show, status: :created, location: @department_entry_membership }\n else\n format.html { render :new }\n format.json { render json: @department_entry_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :stripe_customer_id, :mode, :status, :expiration_date, :stripe_token, :referer_path)\n end",
"def membership_params\n params.require(:membership).permit(:user_id, :beer_club_id)\n end",
"def list_memberships(user)\n get(\"/#{user}/lists/memberships.json\")\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def membership_params\n params.require(:community_membership).permit(:role)\n end",
"def create(params, membership)\n # Send payload to blip\n data = {\n initials: (params[4].nil? ? params[5][0] : params[4].tr('^a-zA-Z', '')),\n firstname: (params[5].nil? ? params[4][0] : params[5]),\n lastname: [params[6], params[7]].reject{|e| e.nil? or e.empty?}.join(' '),\n email: (params[3].nil? ? 'unknown@nieuwedelft.nl.invalid' : params[3]),\n gender: params[9] == 'Vrouw' ? 'F' : 'M',\n phone: params[14],\n mobile: params[2],\n phone_parents: params[24],\n address: [params[10], params[11], params[12]].join(' '),\n membership: membership,\n }\n begin\n unless params[15].nil?\n data[:dateofbirth] = Date.strptime(params[15], '%d-%m-%Y').strftime('%Y-%m-%d')\n end\n rescue\n $problems.write \"#{$index}, #{data[:firstname]} #{data[:lastname]}, Birthdate ignored\\n\"\n end\n blip = post('https://people.i.bolkhuis.nl/persons', data)\n\n # Grab uid\n unless blip == nil\n uid = blip['uid']\n\n # Send payload to operculum\n put(\"https://operculum.i.bolkhuis.nl/person/#{uid}\", {\n nickname: params[8],\n study: params[16],\n alive: params[17].nil?,\n inauguration: params[25],\n resignation_letter: params[26],\n resignation: params[27],\n })\n end\nend",
"def create\n @mission = Mission.new(mission_params)\n\n respond_to do |format|\n if @mission.save\n format.html { redirect_to @mission, notice: 'Mission was successfully created.' }\n format.json { render :show, status: :created, location: @mission }\n else\n format.html { render :new }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @mission = Mission.new(mission_params)\n\n respond_to do |format|\n if @mission.save\n format.html { redirect_to @mission, notice: 'Mission was successfully created.' }\n format.json { render :show, status: :created, location: @mission }\n else\n format.html { render :new }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n # PUNDIT_REVIEW_AUTHORIZE\n # PUNDIT_CHECK_AUTHORIZE\n # authorize Portal::SchoolMembership\n @school_membership = Portal::SchoolMembership.new(portal_school_membership_strong_params(params[:school_membership]))\n\n respond_to do |format|\n if @school_membership.save\n flash['notice'] = 'Portal::SchoolMembership was successfully created.'\n format.html { redirect_to(@school_membership) }\n format.xml { render :xml => @school_membership, :status => :created, :location => @school_membership }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @school_membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def membership_params\n params[:membership][:community_id] = @community.id\n throw \"Not a superadmin!\" if params[:membership][:role_id] == Membership::ADMIN unless check_super_admin\n params.require(:membership).permit(:user_id, :community_id, :role_id, :application_info, :notes)\n end",
"def create\n\n @user = User.where(firstName: params[:user][:firstName]).first\n @loop = Loop.find(params[:loop_id])\n\n if @user\n lm = @user.loop_memberships.build(loop_id: @loop.id)\n lm.status = \"pending\"\n lm.author_id = current_user.id\n lm.save\n flash[:success] = \"invitation sent\"\n redirect_to loop_path(@loop)\n else \n flash[:error] = \"error with invitation\"\n redirect_to loop_path(@loop)\n end\n\n end",
"def create\n @mission = Mission.new(mission_params)\n\n respond_to do |format|\n if @mission.save\n format.html { redirect_to @mission, notice: 'Mission was successfully created.' }\n format.json { render json: @mission, status: :created, location: @mission }\n else\n format.html { render action: \"new\" }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_member\n return unless (request.post? && params[:student_user_name])\n # add member to the group with status depending if group is empty or not\n grouping = Grouping.find(params[:grouping_id])\n @assignment = Assignment.find(params[:id], include: [{groupings: [{student_memberships: :user, ta_memberships: :user}, :group]}])\n student = Student.find_by_user_name(params[:student_user_name])\n if student.nil?\n @error = \"Could not find student with user name #{params[:student_user_name]}\"\n render :error_single\n return\n end\n set_membership_status = grouping.student_memberships.empty? ?\n StudentMembership::STATUSES[:inviter] :\n StudentMembership::STATUSES[:accepted]\n grouping.invite(params[:student_user_name], set_membership_status)\n grouping.reload\n @grouping = construct_table_row(grouping, @assignment)\n end",
"def index\n @memberships = @user.memberships\n\n respond_to do |format|\n format.html # index.rhtml\n end\n end",
"def index\n @memberships = Membership.all\n end",
"def index\n @memberships = Membership.all\n end",
"def index\n @memberships = Membership.all\n end"
] |
[
"0.74409395",
"0.7237003",
"0.719769",
"0.70858735",
"0.701683",
"0.68935937",
"0.6871786",
"0.6861041",
"0.67830914",
"0.6780647",
"0.67684424",
"0.6766007",
"0.6600742",
"0.6540821",
"0.65174806",
"0.6459168",
"0.6427318",
"0.6395617",
"0.63640666",
"0.63258076",
"0.6318312",
"0.6308603",
"0.6283067",
"0.6260112",
"0.62587935",
"0.62574714",
"0.6241234",
"0.62304235",
"0.62008125",
"0.61935055",
"0.61745334",
"0.6162407",
"0.61612374",
"0.6157631",
"0.61491203",
"0.6138499",
"0.61177015",
"0.60719925",
"0.6066862",
"0.6055398",
"0.60419047",
"0.60180646",
"0.6013316",
"0.6008135",
"0.600208",
"0.60016954",
"0.5991841",
"0.59895664",
"0.5983802",
"0.59778273",
"0.5963814",
"0.59608346",
"0.5957049",
"0.59516394",
"0.59436005",
"0.59314597",
"0.59275365",
"0.5911274",
"0.5889661",
"0.5875664",
"0.58700234",
"0.58650035",
"0.58629435",
"0.5860878",
"0.5859995",
"0.5832314",
"0.5828837",
"0.58229995",
"0.58229995",
"0.5822904",
"0.58211434",
"0.5819519",
"0.58060503",
"0.58008426",
"0.579091",
"0.5782982",
"0.577949",
"0.5773822",
"0.5771076",
"0.5771076",
"0.5771076",
"0.5771076",
"0.5771076",
"0.5771076",
"0.5771076",
"0.5771076",
"0.5771076",
"0.576865",
"0.57668775",
"0.576355",
"0.576355",
"0.5761242",
"0.57577425",
"0.57476854",
"0.57345855",
"0.5728483",
"0.57237184",
"0.5716756",
"0.5716756",
"0.5716756"
] |
0.7569
|
0
|
PATCH/PUT /mission_memberships/1 PATCH/PUT /mission_memberships/1.json
|
def update
respond_to do |format|
if @mission_membership.update(mission_membership_params)
format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully updated.' }
format.json { render :show, status: :ok, location: @mission_membership }
else
format.html { render :edit }
format.json { render json: @mission_membership.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n @membership ||= Membership.find(params[:id])\n\n respond_to do |format|\n if @membership.update_attributes(params[:membership])\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @membership = Membership.find(params[:id])\n\n respond_to do |format|\n if @membership.update_attributes(params[:membership])\n format.html { redirect_to @membership, :notice => 'Membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def UpdateMembership params = {}\n \n APICall(path: 'group_memberships.json',method: 'PUT',payload: params.to_json)\n \n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: \"Membership was successfully updated.\" }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize @organization_membership\n\n if @organization_membership.update(organization_membership_update_params)\n head :no_content\n else\n render json: @organization_membership.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @member, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to community_memberships_path(@community), notice: 'Community membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tribal_membership.update(tribal_membership_params)\n format.html { redirect_to @tribal_membership, notice: 'Tribal membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @tribal_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to class_group_memberships_url, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_mission_membership\n @mission_membership = MissionMembership.find(params[:id])\n end",
"def update\n\n respond_to do |format|\n if @membership.update_attributes(params[:membership])\n format.html { redirect_to edit_site_url(@membership.site), notice: 'Membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @membership = Adhocracy::Membership.find(params[:id])\n\n authorize! :manage, @membership\n\n if @membership.update(membership_params)\n head :no_content\n else\n render_validation_errors @membership.errors\n end\n end",
"def update\n @loop_membership = LoopMembership.find(params[:id])\n\n respond_to do |format|\n if @loop_membership.update_attributes(params[:loop_membership])\n format.html { redirect_to @loop_membership, notice: 'Loop membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @loop_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @organization_membershipship = current_person.organization_memberships.find(params[:id])\n\n respond_to do |format|\n if @organization_membershipship.update_attributes(params[:organization_membershipship])\n format.html { redirect_to(@organization_membershipship, :notice => 'Organization membership was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @organization_membershipship.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @team_membership.update(team_membership_params)\n format.html { redirect_to @team_membership, notice: 'Team membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @team_membership }\n else\n format.html { render :edit }\n format.json { render json: @team_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @membership = Membership.find(params[:id])\n auth!\n respond_to do |format|\n if (@membership.can_resign_leadership?(membership_params['level'])) && (@membership.update_attributes(membership_params))\n format.html { redirect_to(edit_group_path(@group), :notice => t(:membership_updated)) }\n format.xml { head :ok }\n else\n format.html { redirect_to @group, :notice => @group.errors }\n format.xml { render :xml => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @membership = args[:membership] if args.key?(:membership)\n end",
"def update!(**args)\n @membership = args[:membership] if args.key?(:membership)\n end",
"def mission_membership_params\n params.require(:mission_membership).permit(:user_id, :mission_id)\n end",
"def update\n respond_to do |format|\n if @students_project_membership.update(students_project_membership_params)\n format.html { redirect_to @students_project_membership, notice: 'Students project membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @students_project_membership }\n else\n format.html { render :edit }\n format.json { render json: @students_project_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @membership.assign_attributes(membership_params)\n @membership.user.no_password = true\n \n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @admission.update_attributes(admission_params)\n end",
"def update\n @mission = Mission.find(params[:id])\n\n respond_to do |format|\n if @mission.update_attributes(mission_params)\n format.html { redirect_to @mission, notice: 'Mission was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def test_should_update_group_user_via_API_JSON\r\n # lookup user's membership\r\n get \"memberships/find.json?api_key=testapikey&user_id=4&group_id=1\"\r\n membership = JSON.parse(response.body)\r\n membership_id = membership['id']\r\n assert membership_id == 3, 'Incorrect membership id'\r\n assert membership['role_id'] == Role.find_by_rolename('user').id, 'Incorrect role id'\r\n \r\n # promote user to group admin\r\n put \"/memberships/#{membership_id}.xml\", :api_key => 'testapikey',\r\n :membership => {:user_id => 4,\r\n :group_id => 1,\r\n :role_id => Role.find_by_rolename('group_admin') }\r\n assert_response :success\r\n end",
"def update!(**args)\n @memberships = args[:memberships] if args.key?(:memberships)\n @request_id = args[:request_id] if args.key?(:request_id)\n @space = args[:space] if args.key?(:space)\n end",
"def update\n respond_to do |format|\n if @mission.update(mission_params)\n format.html { redirect_to @mission, notice: 'Mission was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission }\n else\n format.html { render :edit }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @mission.update(mission_params)\n format.html { redirect_to @mission, notice: 'Mission was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission }\n else\n format.html { render :edit }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @mission.update(mission_params)\n format.html { redirect_to @mission, notice: 'Mission was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission }\n else\n format.html { render :edit }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\t\t@membership = Membership.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tif @membership.update_attributes(params[:membership])\n\t\t\t\tformat.html { redirect_to(@membership, :notice => 'Membership was successfully updated.') }\n\t\t\t\tformat.xml\t{ head :ok }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"edit\" }\n\t\t\t\tformat.xml\t{ render :xml => @membership.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def update_membership(organization_id, membership_id, params)\n http.put(\"#{membership_endpoint(organization_id)}/#{membership_id}\", body: params) do |response|\n Rexpense::Entities::Membership.new response.parsed_body\n end\n end",
"def update\n @lab_membership = LabMembership.find(params[:id])\n @user = @lab_membership.user\n\n respond_to do |format|\n if @lab_membership.load(params[:lab_membership]) && @lab_membership.save\n flash[:notice] = 'LabMembership was successfully updated.'\n format.html { redirect_to( user_lab_memberships_path(@user) ) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @lab_membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @research_group_membership.update(research_group_membership_params)\n format.html { redirect_to @research_group_membership, notice: 'Research group membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @research_group_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # no spoofing of acceptance\n params[:membership].delete('network_established_at') if params[:membership][:network_established_at]\n params[:membership].delete('user_established_at') if params[:membership][:user_established_at]\n \n respond_to do |format|\n if @membership.update_attributes(params[:membership])\n flash[:notice] = 'Membership was successfully updated.'\n format.html { redirect_to user_membership_path(@membership.user_id, @membership) }\n else\n format.html { render :action => \"edit\" }\n end\n end\n end",
"def update\n @mission = Mission.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @membership_option.update(membership_option_params)\n format.html { redirect_to @membership_option, notice: 'Membership option was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership_option }\n else\n format.html { render :edit }\n format.json { render json: @membership_option.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_memberships\n update_children\n update_parents\n end",
"def update\n respond_to do |format|\n if @os_groups_membership.update(os_groups_membership_params)\n format.html { redirect_to @os_groups_membership, notice: 'Os groups membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @os_groups_membership }\n else\n format.html { render :edit }\n format.json { render json: @os_groups_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def test_should_update_membership\n login_as(:john)\n put :update, :id => 1, :membership => { }\n assert_response :redirect\n end",
"def test_should_update_membership\n login_as(:john)\n put :update, :id => 1, :membership => { }\n assert_response :redirect\n end",
"def update\n @membership = Membership.find(params[:id])\n if @membership.update_attributes(membership_params)\n flash[:success] = \"Updated membership.\"\n redirect_to group_members_url(@group)\n end\n end",
"def update\n @medium_mission_inv = MediumMissionInv.find(params[:id])\n\n respond_to do |format|\n if @medium_mission_inv.update_attributes(params[:medium_mission_inv])\n format.html { redirect_to @medium_mission_inv, notice: 'Medium mission inv was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @medium_mission_inv.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @mission = Mission.find(params[:id])\n\n respond_to do |format|\n if @mission.update_attributes(params[:mission])\n format.html { redirect_to @mission, :notice => 'Changements bien pris en compte' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @mission.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership_record.update(membership_record_params)\n format.html { redirect_to @membership_record, notice: 'Membership record was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership_record }\n else\n format.html { render :edit }\n format.json { render json: @membership_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership_clerk.update(membership_clerk_params)\n format.html { redirect_to @membership_clerk, notice: 'Membership clerk was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership_clerk }\n else\n format.html { render :edit }\n format.json { render json: @membership_clerk.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @account_membership = AccountMembership.find(params[:id])\n\n respond_to do |format|\n if @account_membership.update_attributes(params[:account_membership])\n flash[:notice] = 'AccountMembership was successfully updated.'\n format.html { redirect_to(@account_membership) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @account_membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @membership_type.update(membership_type_params)\n @membership_type = MembershipType.new\n @membership_types = MembershipType.all\n \n end",
"def update\n @contact = @business.contacts.find_by_padma_id(params[:contact_id]) if params[:business_id].present?\n\n if (@membership = (@contact.try(:current_membership) || @contact.memberships.where(external_id: membership_params[\"external_id\"]).first ) )\n if @membership.external_id == membership_params[:external_id]\n # update\n @success = @membership.update(membership_params)\n else\n # close and create new\n @membership.update(closed_on: membership_params[:starts_on])\n\n @membership = Membership.new(membership_params.merge({business: @business, contact_id: @contact.id}))\n if membership_params[:payment_type_name]\n # requires for business to already be set\n @membership.payment_type_name = membership_params[:payment_type_name]\n end\n @success = @membership.save\n end\n else\n # create\n @membership = Membership.new(membership_params.merge({business: @business, contact_id: @contact.id}))\n if membership_params[:payment_type_name]\n # requires for business to already be set\n @membership.payment_type_name = membership_params[:payment_type_name]\n end\n @success = @membership.save\n end\n\n if @success && @membership\n render json: @membership, root: false, status: 201\n else\n render json: {message: @membership.errors}, status: 400\n end\n end",
"def update\n respond_to do |format|\n if @membership_contribution.update(membership_contribution_params)\n format.html { redirect_to @membership_contribution, notice: 'Membership contribution was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership_contribution }\n else\n format.html { render :edit }\n format.json { render json: @membership_contribution.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @membership_fee = MembershipFee.find(params[:id])\n\n respond_to do |format|\n if @membership_fee.update_attributes(params[:membership_fee])\n format.html { redirect_to @membership_fee, notice: 'Membership fee was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @membership_fee.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @mostsmallmission = Mostsmallmission.find(params[:id])\n\n respond_to do |format|\n if @mostsmallmission.update_attributes(params[:mostsmallmission])\n format.html { redirect_to @mostsmallmission, notice: 'Mostsmallmission was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @mostsmallmission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @mission_status.update(mission_status_params)\n format.html { redirect_to [:admin, @mission_status], notice: 'Mission status was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @mission_status.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(uid, params, membership)\n data = {\n initials: (params[4].nil? ? params[5][0] : params[4].tr('^a-zA-Z', '')),\n email: (params[3].nil? ? 'unknown@nieuwedelft.nl.invalid' : params[3]),\n gender: params[9] == 'Vrouw' ? 'F' : 'M',\n phone: params[14],\n mobile: params[2],\n phone_parents: params[24],\n address: [params[10], params[11], params[12]].join(' '),\n membership: membership,\n }\n begin\n unless params[15].nil?\n data[:dateofbirth] = Date.strptime(params[15], '%d-%m-%Y').strftime('%Y-%m-%d')\n end\n rescue\n $problems.write \"#{$index}, #{data[:firstname]} #{data[:lastname]}, Birthdate ignored\\n\"\n end\n patch(\"https://people.i.bolkhuis.nl/persons/#{uid}\", data)\n\n # Send payload to operculum\n put(\"https://operculum.i.bolkhuis.nl/person/#{uid}\", {\n nickname: params[8],\n study: params[16],\n alive: params[17].nil?,\n inauguration: params[25],\n resignation_letter: params[26],\n resignation: params[27],\n })\nend",
"def update\n if params[:membership][:to_present].eql?(\"1\")\n current_date = Time.now\n params[:membership][\"until_date(1i)\"] = params[:membership][:until_year] = current_date.strftime(\"%Y\")\n params[:membership][\"until_date(2i)\"] = current_date.strftime(\"%m\")\n else\n params[:membership][\"until_date(1i)\"] = params[:membership][:until_year]\n end\n params[:membership][\"from_date(1i)\"] = params[:membership][:from_year]\n params[:membership][\"from_date(3i)\"] = \"1\"\n params[:membership][\"until_date(3i)\"] = \"1\"\n \n @membership = Membership.find(params[:id])\n\n if @membership.update_attributes(params[:membership])\n if request.xhr?\n @memberships = Membership.all(:conditions => \"user_id = '#{current_user.id}'\", :order => \"created_at DESC\")\n render :update do |page|\n page.replace_html \"membership_index_container\", :partial => \"index\", :locals => {:memberships => @memberships}\n page << \"$(\\\"add_membership_form\\\").innerHTML = \\\"\\\"\"\n end\n end\n else\n if request.xhr?\n render :update do |page|\n if @membership.errors.to_a.map{|err| err[0]}.include?(\"name\")\n page << \"$('membership_name_must_unique_0').show()\"\n page << \"$('membership_name_cant_be_blank_0').hide()\"\n elsif @membership.errors.to_a.map{|err| err[0]}.include?(\"until_date\")\n page << \"$('membership_end_year_must_greater_than_start_year_0').show()\"\n end\n end\n end\n end\n end",
"def update\n @medium_mission = MediumMission.find(params[:id])\n\n respond_to do |format|\n if @medium_mission.update_attributes(params[:medium_mission])\n format.html { redirect_to @medium_mission, notice: 'Medium mission was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @medium_mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def notifications\n membership = current_account.memberships.find_by(\n :id => params[:membership][:id]) if params[:membership]\n\n if membership and membership.update_attributes(membership_params.except(:id))\n flash[:success] = _('Notifications updated.')\n end\n end",
"def set_membership\n @membership = @organization.memberships.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @mission_capacity.update(mission_capacity_params)\n format.html { redirect_to @mission_capacity, notice: 'Mission capacity was successfully updated.' }\n format.json { render :show, status: :ok, location: @mission_capacity }\n else\n format.html { render :edit }\n format.json { render json: @mission_capacity.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if !params[:roles].include?('president') && @member.has_role?(:president) && !Tenant.current.has_presidents\n format.html { redirect_to member_path(@member), notice: 'Please select other user as President.' }\n elsif @member.update(member_params)\n remove_roles\n add_roles(params[:roles])\n format.html { redirect_to member_path(@member), notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @mission.update(mission_params)\n MissionMailer.update_mission_b(Mission.last).deliver_now\n MissionMailer.update_mission_e(Mission.last).deliver_now\n format.html { redirect_to @mission.etablissement, notice: 'La Proposition a bien été modifiée.' }\n format.json { render :show, status: :ok, location: @mission.etablissement }\n else\n format.html { render :edit }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @bare_metal_admin_cluster_id = args[:bare_metal_admin_cluster_id] if args.key?(:bare_metal_admin_cluster_id)\n @membership = args[:membership] if args.key?(:membership)\n end",
"def update\n @aiit_member = AiitMember.find(params[:id])\n\n respond_to do |format|\n if @aiit_member.update_attributes(params[:aiit_member])\n format.html { redirect_to @aiit_member, notice: 'Aiit member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @aiit_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership_confirmation.update(membership_confirmation_params)\n format.html { redirect_to @membership_confirmation, notice: 'Membership confirmation was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership_confirmation }\n else\n format.html { render :edit }\n format.json { render json: @membership_confirmation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership_pkg.update(membership_pkg_params)\n format.html { redirect_to @membership_pkg, notice: 'Membership pkg was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership_pkg }\n else\n format.html { render :edit }\n format.json { render json: @membership_pkg.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n #logger.info \"Put parameters: #{params.to_json}\"\n\n if @membership.admin \n if @group.update_attributes(params[:group])\n head :no_content\n else\n render json: @group.errors, status: :unprocessable_entity\n end\n else \n render json: {error: \"YOU MUST BE AN ADMINISTRATOR TO COMPLETE THIS ACTION\"}, status: :unprocessable_entity\n end \n end",
"def update\n\n available_users\n \n #assign users to mission\n if params[:user_ids].present?\n user = params[:user_ids].delete_if{ |x| x.empty? }\n @mission.users = []\n @mission.users << User.find(params[:user_ids]) \n end\n respond_to do |format|\n if @mission.update(mission_params)\n format.html { redirect_to [:admin, @mission], notice: 'Mission was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @mission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # this action is not provided for partyroles\n end",
"def update\n @call_list_membership = CallListMembership.find(params[:id])\n params[:call_list_membership][:oncall_candidate] = false if params[:call_list_membership][:oncall_candidate] == 0\n\n respond_to do |format|\n if @call_list_membership.update_attributes(params[:call_list_membership])\n format.html { redirect_to @call_list_membership, :notice => 'Call list membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @call_list_membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n user = @membership.user\n school = @membership.school\n current_role = @membership.primary_role.to_sym\n respond_to do |format|\n if @membership.update(membership_params)\n if @membership.primary_role_changed?\n user.remove_role(current_role, school)\n case @membership.primary_role.to_sym\n when :account_owner\n user.add_role(\"account_owner\", school)\n when :staff\n user.add_role(\"staff\", school)\n when :educator\n user.add_role(\"educator\", school)\n when :learner\n user.add_role(\"learner\", school)\n when :parent_or_guardian\n user.add_role(\"parent\", school)\n when :friend_of_school\n user.add_role(\"friend\", school)\n end\n end\n format.html { redirect_to @membership, notice: 'School registration was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @admission.update(admission_params)\n format.html { redirect_to @admission, notice: 'Admission information was successfully updated.' }\n format.json { render :show, status: :ok, location: @admission }\n else\n format.html { render :edit }\n format.json { render json: @admission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @memberships = args[:memberships] if args.key?(:memberships)\n @next_page_token = args[:next_page_token] if args.key?(:next_page_token)\n end",
"def update!(**args)\n @memberships = args[:memberships] if args.key?(:memberships)\n @next_page_token = args[:next_page_token] if args.key?(:next_page_token)\n end",
"def update\n respond_to do |format|\n if @admission.update(admission_params)\n format.html { redirect_to @admission, notice: 'Admission was successfully updated.' }\n format.json { render :show, status: :ok, location: @admission }\n else\n format.html { render :edit }\n format.json { render json: @admission.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def set_membership\n @membership = Membership.find(params[:id])\n end",
"def update!(**args)\n @membership = args[:membership] if args.key?(:membership)\n @vmware_admin_cluster_id = args[:vmware_admin_cluster_id] if args.key?(:vmware_admin_cluster_id)\n end",
"def update\n account = current_organization.accounts.find(params[:id])\n return forbidden unless account && current_account.allowed_to_edit_account?(account, current_organization)\n return json(account) unless account.update_attributes pick(params, :first_name, :last_name, :email,:language, :document_language)\n\n role = pick(params, :role)\n #account.update_attributes(role) if !role.empty? && current_account.admin?\n membership = current_organization.role_of(account)\n membership.update_attributes(role) if !role.empty? && current_account.admin?\n password = pick(params, :password)[:password]\n if (current_account.id == account.id) && password\n account.update(password: password)\n end\n json account.canonical(membership: membership)\n end",
"def create\n #sanity checks, can only modify memberships that you own\n if params[:user_id].to_i != current_user.id then\n render json: {message:'You do not own the membership list'}, :status => :unprocessable_entity\n return\n end\n\n #ensure the membership params is there\n unless params.has_key? :memberships then\n #render json: {message:'memberships list not found'}, :status => :unprocessable_entity\n #return\n #this could me no membership at all\n params[:memberships] = {}\n end\n\n #set the new memberships state\n current_user.set_memberships params[:memberships]\n\n render json: {\n message:'message received from server',\n memberships:User.find(params[:user_id]).memberships.map{ |x| x.attributes.merge({club_name: x.club_name})}\n }\n end",
"def update\n respond_to do |format|\n action_message_for(@team_profile.content_item.status)\n if update_team_profile\n format.html { redirect_to redirect_target(@team_profile), flash: @feedback_flash }\n format.json { render :show, status: :ok, location: @team_profile }\n else\n 3.times { @team_profile.team_memberships.new }\n 1.times { @team_profile.subsets.new }\n @team_profile.content_item.status = session[:content_item_status]\n format.html { render :edit }\n format.json { render json: @team_profile.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @missionary = Missionary.find(params[:id])\n \n respond_to do |format|\n if @missionary.update_attributes(params[:missionary])\n format.html{ redirect_to(@missionary, :notice => \"#{@missionary.full_name} was successfully updated.\") }\n else\n format.html{ render :action => \"edit\"}\n end\n end\n end",
"def create\n @mission_membership = MissionMembership.new(mission_membership_params)\n\n respond_to do |format|\n if @mission_membership.save\n format.html { redirect_to @mission_membership, notice: 'Mission membership was successfully created.' }\n format.json { render :show, status: :created, location: @mission_membership }\n else\n format.html { render :new }\n format.json { render json: @mission_membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @research_group_member.update(research_group_member_params)\n format.html { redirect_to @research_group_member, notice: 'Research group member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @research_group_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n \n add_plan_to_user_if_specified!\n format.html { redirect_to(@member, :notice => 'Member was successfully updated.') }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n\t \n\t @enrollment = Enrollment.find(params[:enrollment_id], :include => :contract)\n\t @meeting = Meeting.find(params[:meeting_id])\n\t if @enrollment\n\t privs = @enrollment.contract.privileges(@user)\n\t render :text => \"You don't have privileges to do this.\", :status=>500 and return unless privs[:edit]\n\t \n\t participant = update_attendance_for_enrollment(@meeting, @enrollment, params)\n\t end\n \n render :json => {:id => participant.id}.to_json\n\tend",
"def update\n # byebug \n respond_to do |format|\n if self.current_member && self.current_member.id == params[:id].to_i\n if @member.update(member_params)\n format.json { render :show, status: :ok, location: @member }\n else\n return api_error(status: :unprocessable_entity, message: @member.errors)\n end\n else\n return api_error(status: 401, message: '没有操作权限')\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.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 @monthly_interest = MonthlyInterest.find(params[:id])\n\n respond_to do |format|\n if @monthly_interest.update_attributes(params[:monthly_interest])\n format.html { redirect_to @monthly_interest, notice: 'Monthly interest was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @monthly_interest.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.7122485",
"0.70846295",
"0.70549154",
"0.70328283",
"0.70328283",
"0.70328283",
"0.70328283",
"0.70328283",
"0.7025758",
"0.70087314",
"0.6939785",
"0.6920675",
"0.69048536",
"0.68792355",
"0.6831834",
"0.6770367",
"0.66976655",
"0.6664359",
"0.66423",
"0.658141",
"0.6571264",
"0.65504754",
"0.65504754",
"0.6544605",
"0.6499112",
"0.6492971",
"0.6487056",
"0.64537674",
"0.6438241",
"0.64174986",
"0.6412694",
"0.6412694",
"0.6412694",
"0.6404159",
"0.6376227",
"0.6352632",
"0.63500977",
"0.63456213",
"0.6278976",
"0.6276062",
"0.6245948",
"0.62201804",
"0.62162083",
"0.62162083",
"0.6208916",
"0.6202776",
"0.6200601",
"0.62000227",
"0.6197262",
"0.6192557",
"0.61919296",
"0.6178569",
"0.6165864",
"0.61420053",
"0.6116311",
"0.6106031",
"0.6098731",
"0.60883987",
"0.6084484",
"0.6077495",
"0.606329",
"0.6053391",
"0.6052955",
"0.6039731",
"0.6034902",
"0.603302",
"0.6016497",
"0.5994307",
"0.5985756",
"0.598558",
"0.59498036",
"0.5938997",
"0.5928774",
"0.5918897",
"0.59062374",
"0.5894223",
"0.5894223",
"0.5893712",
"0.5887816",
"0.5887816",
"0.5887816",
"0.5887816",
"0.5887816",
"0.5887816",
"0.5887816",
"0.5887816",
"0.5887816",
"0.58791554",
"0.58788645",
"0.58570176",
"0.5826786",
"0.5813956",
"0.5813522",
"0.581061",
"0.5810011",
"0.58060855",
"0.58015877",
"0.5794748",
"0.57897145",
"0.5785281"
] |
0.77228504
|
0
|
DELETE /mission_memberships/1 DELETE /mission_memberships/1.json
|
def destroy
@mission_membership.destroy
respond_to do |format|
format.html { redirect_to mission_memberships_url, notice: 'Mission membership was successfully destroyed.' }
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership ||= Membership.find(params[:id])\n @membership.destroy\n\n respond_to do |format|\n format.html { redirect_to memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to @user }\n format.json { head :no_content }\n end\n end",
"def DeleteMembership id\n \n APICall(path: \"group_memberships/#{id}.json\",method: 'DELETE')\n \n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url, notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url, notice: \"Membership was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @tribal_membership.destroy\n respond_to do |format|\n format.html { redirect_to tribal_memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loop_membership = LoopMembership.find(params[:id])\n @loop_membership.destroy\n\n respond_to do |format|\n format.html { redirect_to loop_memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to groups_path, notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to member_url(@membership.member), notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to @community, notice: 'Community membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n if current_user.role(@project) == :admin && @membership.admin?\n return respond_to do |format|\n format.json { head :forbidden }\n end\n end\n\n @membership.destroy\n head :no_content\n end",
"def destroy\n @membership.destroy\n\n respond_to do |format|\n format.html { redirect_to edit_site_url(@membership.site) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership = Adhocracy::Membership.find(params[:id])\n\n authorize! :manage, @membership\n @membership.destroy\n\n head :no_content\n end",
"def destroy\n @lab_membership = LabMembership.find(params[:id])\n @user = @lab_membership.user\n @lab_membership.destroy\n\n respond_to do |format|\n format.html { redirect_to( user_lab_memberships_path(@user) ) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @students_project_membership.destroy\n respond_to do |format|\n format.html { redirect_to students_project_memberships_url, notice: 'Students project membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @susu_membership.destroy\n end",
"def destroy\n @research_group_membership.destroy\n respond_to do |format|\n format.html { redirect_to research_group_memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @os_groups_membership.destroy\n respond_to do |format|\n format.html { redirect_to os_groups_memberships_url, notice: 'Os groups membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership_clerk.destroy\n respond_to do |format|\n format.html { redirect_to membership_clerks_url, notice: 'Membership clerk was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission = Mission.find(params[:id])\n @mission.destroy\n\n respond_to do |format|\n format.html { redirect_to missions_url }\n format.json { head :ok }\n end\n end",
"def destroy\n user = @membership.user\n school = @membership.school\n user_roles = user.roles\n @membership.destroy\n user_roles.delete_all\n respond_to do |format|\n format.html { redirect_to school_memberships_path(@membership.school), notice: 'Scool registration was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission = Mission.find(params[:id])\n @mission.destroy\n\n respond_to do |format|\n format.html { redirect_to missions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if current_user.type == \"Clinician\"\n @membership = Membership.find_by(member_id: params[:id], clinician_id: current_user.id)\n else\n @membership = Membership.find_by(member_id: current_user.id, clinician_id: params[:id])\n end\n\n if @membership\n begin\n authorize! :cancel, @membership\n CancelMembershipService.new(membership: @membership).perform\n render json: { status: :ok }\n rescue StandardError => e\n render json: {errors: e.message}, status: :unprocessable_entity\n end\n else\n render json: { status: :not_found }\n end\n end",
"def destroy\n @account_membership = AccountMembership.find(params[:id])\n @account_membership.destroy\n\n respond_to do |format|\n format.html { redirect_to(account_memberships_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @mission.destroy\n respond_to do |format|\n format.html { redirect_to admin_missions_url, notice: 'Mission was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @team_membership.destroy\n respond_to do |format|\n format.html { redirect_to team_memberships_url, notice: 'Team membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership_record.destroy\n respond_to do |format|\n format.html { redirect_to membership_records_url, notice: 'Membership record was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission = Mission.find(params[:id])\n @mission.destroy\n end",
"def destroy\n @membership = Membership.find(params[:id])\n @membership.destroy\n\n redirect_to(chat_rooms_url)\n end",
"def destroy\n @aiit_member = AiitMember.find(params[:id])\n @aiit_member.destroy\n\n respond_to do |format|\n format.html { redirect_to aiit_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n #if requests comes from a different path, search by the information provided\n current_uri = request.env['PATH_INFO']\n if current_uri == \"/memberships\"\n beer_club_id = params[:membership][:beer_club_id]\n @membership = Membership.find_by_beer_club_id_and_user_id(beer_club_id, current_user.id)\n end\n\n #else we assume, that the delete request came from the usual place, memberships/:id\n unless current_user.nil? or current_user!=@membership.user\n\n @membership.destroy\n respond_to do |format|\n #byebug\n format.html { redirect_to current_user, notice: \"Your membership in #{@membership.beer_club.name} ended.\" }\n format.json { head :no_content }\n end\n else\n redirect_to memberships_url, notice: \"You aren't allowed to touch other users memberships! You bastard.\"\n end\n end",
"def destroy\n @mostsmallmission = Mostsmallmission.find(params[:id])\n @mostsmallmission.destroy\n\n respond_to do |format|\n format.html { redirect_to mostsmallmissions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission_status.destroy\n respond_to do |format|\n format.html { redirect_to admin_mission_statuses_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium_mission = MediumMission.find(params[:id])\n @medium_mission.destroy\n\n respond_to do |format|\n format.html { redirect_to medium_missions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n\t\t@membership = Membership.find(params[:id])\n\t\t@membership.destroy\n\n\t\trespond_to do |format|\n\t\t\tformat.html { redirect_to(memberships_url, :notice => \"Membership successfully destroyed.\") }\n\t\t\tformat.xml\t{ head :ok }\n\t\tend\n\tend",
"def destroy\n @membership_type = MembershipType.find(params[:id])\n @membership_type.destroy\n\n respond_to do |format|\n format.html { redirect_to '/preferences/members_management?tab=membership_types', :notice => \"Membership Type deleted\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium_mission_inv = MediumMissionInv.find(params[:id])\n @medium_mission_inv.destroy\n\n respond_to do |format|\n format.html { redirect_to medium_mission_invs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n @id = params[:id]\n respond_to do |format|\n format.html { redirect_to class_group_memberships_path(@class_group), notice: 'Membership was successfully destroyed.' }\n format.js { render :layout => false }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership_option.destroy\n respond_to do |format|\n format.html { redirect_to membership_options_url, notice: 'Membership option was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission.destroy\n respond_to do |format|\n format.html { redirect_to missions_url, notice: 'Mission was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission.destroy\n respond_to do |format|\n format.html { redirect_to missions_url, notice: 'Mission was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy \n @oc_member = OcMember.find(params[:id])\n @oc_member.destroy\n\n respond_to do |format|\n format.html { redirect_to oc_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership = Membership.find(params[:id])\n auth!\n respond_to do |format|\n #throw a negative one at a function expecting a membership level to indicate deletion\n if @membership.can_resign_leadership?(-1)\n process_notification(@membership, {:group_name => @membership.group.name}, :action => 'destroy', :owner => current_user, :recipient => @membership.user)\n if @membership.destroy\n format.html { redirect_to({:controller => :groups, :action => :edit, :id => @group}, :notice => t(:member_removed)) }\n format.xml { head :ok }\n else\n format.html { redirect_to @group, :notice => t(:membership_denied) }\n format.xml { render :xml => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end\n end",
"def destroy\n club_id = @membership.beer_club.id\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to beer_club_path(club_id), notice: 'You are no longer a member of this club' }\n format.json { head :no_content }\n end\n end",
"def destroy_membership(organization_id, membership_id)\n http.delete(\"#{membership_endpoint(organization_id)}/#{membership_id}\") do |response|\n true\n end\n end",
"def destroy\n @organization_membershipship = current_person.organization_memberships.find(params[:id])\n @organization_membershipship.destroy\n\n respond_to do |format|\n format.html { redirect_to(person_organization_memberships_path(current_person)) }\n format.js { render :nothing => true }\n format.xml { head :ok }\n end\n end",
"def destroy\n @band_membership = BandMembership.find(params[:id])\n @band_membership.destroy\n\n respond_to do |format|\n format.html { redirect_to(band_memberships_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @admission.destroy\n end",
"def destroy\n @membership_fee = MembershipFee.find(params[:id])\n @membership_fee.destroy\n\n respond_to do |format|\n format.html { redirect_to membership_fees_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership_pkg.destroy\n respond_to do |format|\n format.html { redirect_to membership_pkgs_url, notice: 'Membership pkg was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n \n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @membership.admin \n @group.destroy\n else\n render json: {error: \"YOU MUST BE AN ADMINISTRATOR TO COMPLETE THIS ACTION\"}, status: :unprocessable_entity\n end \n head :no_content\n end",
"def destroy\n @missionary = Missionary.find(params[:id])\n @missionary.destroy\n end",
"def destroy\n @membership = Membership.find(params[:id])\n auth!\n respond_to do |format|\n process_notification(@membership, {}, process_notification_options({\n params: {\n level: @membership.level_name,\n member_id: @membership.user.id,\n member_name: @membership.user.name,\n group_id: @membership.group.id,\n group_name: @membership.group.name\n },\n recipient: @membership.user}))\n\n if @membership.destroy\n format.html { redirect_to manage_members_group_path(@group), notice: t(:member_removed) }\n format.xml { head :ok }\n else\n format.html { redirect_to manage_members_group_path(@group), notice: t(:membership_denied) }\n format.xml { render xml: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n @membership_contribution.destroy\n respond_to do |format|\n format.html { redirect_to membership_contributions_url, notice: 'Membership contribution was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n return forbidden unless current_account.admin?\n\n current_organization.memberships.where(account_id: params[:id]).update_all(role: Account::DISABLED)\n json nil\n end",
"def deleteEntityAssociation_membership( entity_id, gen_id)\n params = Hash.new\n params['entity_id'] = entity_id\n params['gen_id'] = gen_id\n return doCurl(\"delete\",\"/entity/association_membership\",params)\n end",
"def destroy\n @company_profile = CompanyProfile.find(params[:company_profile_id]) \n @company_profile_membership.destroy\n respond_to do |format|\n format.html { redirect_to @company_profile, notice: 'Company profile membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @enrollment.destroy\n\n respond_to do |format|\n format.html { redirect_to business_membership_url(@business, @membership) }\n end\n end",
"def destroy\n @membership_kind = MembershipKind.get(params[:id])\n @membership_kind.destroy\n\n respond_to do |format|\n format.html { redirect_to(membership_kinds_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @research_group_member.destroy\n respond_to do |format|\n format.html { redirect_to research_group_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mission_capacity.destroy\n respond_to do |format|\n format.html { redirect_to mission_capacities_url, notice: 'Mission capacity was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership = Membership.find(params[:id])\n @membership.destroy\n\n if request.xhr?\n @memberships = Membership.all(:conditions => \"user_id = '#{current_user.id}'\", :order => \"created_at DESC\")\n render :update do |page|\n page.replace_html \"membership_index_container\", :partial => \"index\", :locals => {:memberships => @memberships}\n end\n end\n end",
"def destroy\n ActiveRecord::Base.transaction do\n if @membership.payment_type == 'Stripe'\n stripe_sub = Stripe::Subscription.retrieve(@membership.stripe_sub_id)\n stripe_sub.delete\n end\n\n @membership.destroy\n\n respond_to do |format|\n format.html { redirect_to @member, notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end\n end",
"def destroy\n @memberships = Membership.where(:project_id => params[:id])\n @memberships.each do |membership|\n membership.destroy\n end\n @project = Project.find(params[:id])\n @project.destroy\n\n respond_to do |format|\n format.html { redirect_to projects_url }\n format.js\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership_confirmation.destroy\n respond_to do |format|\n format.html { redirect_to membership_confirmations_url, notice: 'Membership confirmation was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership = Membership.find(params[:id])\n @membership.destroy\n\n respond_to do |format|\n format.js\n format.html { redirect_to @membership.sub_club, :notice => 'you left:' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admission_category = AdmissionCategory.find(params[:id])\n @admission_category.destroy\n\n respond_to do |format|\n format.html { redirect_to admission_categories_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admission_type = AdmissionType.find(params[:id])\n @admission_type.destroy\n\n respond_to do |format|\n format.html { redirect_to admission_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admission.destroy\n respond_to do |format|\n format.html { redirect_to admissions_url, notice: 'Admission information was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @membership_type.destroy\n @membership_types = MembershipType.all\n end",
"def destroy\n @admission.destroy\n respond_to do |format|\n format.html { redirect_to admissions_url, notice: 'Admission was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_member.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @ipadmission = Ipadmission.find(params[:id])\n @ipadmission.destroy\n\n respond_to do |format|\n format.html { redirect_to(ipadmissions_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @summit.destroy\n respond_to do |format|\n format.html { redirect_to summits_url, notice: 'Summit was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @school_membership = Portal::SchoolMembership.find(params[:id])\n # PUNDIT_REVIEW_AUTHORIZE\n # PUNDIT_CHECK_AUTHORIZE (found instance)\n # authorize @school_membership\n @school_membership.destroy\n\n respond_to do |format|\n format.html { redirect_to(portal_school_memberships_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.json { head :ok }\n end\n end",
"def destroy\n @clnmember = Clnmember.find(params[:id])\n @clnmember.destroy\n\n respond_to do |format|\n format.html { redirect_to clnmembers_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n session[:member_id] = nil\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy_member\n\n #@member = Member.find\n #@member.destroy\n respond_to do |format|\n format.html { redirect_to organizations_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @group = Group.find(params[:id])\n\n mbs = Membership.where \"group_id = ?\", @group.id\n\n mbs.each do |m|\n m.destroy\n end\n\n @group.destroy\n\n respond_to do |format|\n format.html { redirect_to groups_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @member_commision.destroy\n respond_to do |format|\n format.html { redirect_to member_commisions_url, notice: 'Member commision was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @hack_member.destroy\n respond_to do |format|\n format.html { redirect_to hack_members_url }\n format.json { head :no_content }\n end\n end",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def destroy\n @medium_mission_strategy = MediumMissionStrategy.find(params[:id])\n @medium_mission_strategy.destroy\n\n respond_to do |format|\n format.html { redirect_to medium_mission_strategies_url }\n format.json { head :no_content }\n end\n end"
] |
[
"0.77090037",
"0.77090037",
"0.7646792",
"0.7564791",
"0.7497444",
"0.7477663",
"0.7469547",
"0.7458328",
"0.74232525",
"0.7390943",
"0.7321565",
"0.7270806",
"0.72695017",
"0.72127837",
"0.7205155",
"0.71368515",
"0.7113252",
"0.7090446",
"0.7066427",
"0.70397353",
"0.70239115",
"0.7017701",
"0.701538",
"0.70008427",
"0.6993062",
"0.69754255",
"0.69729626",
"0.697201",
"0.6955381",
"0.6923448",
"0.6917818",
"0.68843734",
"0.688186",
"0.68784344",
"0.68705595",
"0.6863451",
"0.68338",
"0.6831793",
"0.68217003",
"0.6821376",
"0.6816336",
"0.67907995",
"0.67907995",
"0.67813766",
"0.67791784",
"0.67745024",
"0.67681676",
"0.67601466",
"0.67462856",
"0.6739644",
"0.67225194",
"0.6721811",
"0.67099684",
"0.6709525",
"0.6686285",
"0.66730744",
"0.66710526",
"0.66688055",
"0.665824",
"0.6640514",
"0.6624657",
"0.6624657",
"0.66132075",
"0.66096705",
"0.6608804",
"0.6603913",
"0.66001385",
"0.65949553",
"0.6589634",
"0.65821534",
"0.65821534",
"0.65749186",
"0.65747154",
"0.65719724",
"0.6554337",
"0.6542048",
"0.6542048",
"0.6542048",
"0.6542048",
"0.6542048",
"0.6542048",
"0.6542048",
"0.65378517",
"0.6535044",
"0.6535044",
"0.6525216",
"0.6518653",
"0.65098655",
"0.65072984",
"0.6506477",
"0.65032876",
"0.65003574",
"0.64957064",
"0.64934534",
"0.64882195",
"0.64852065",
"0.64659685",
"0.6464428",
"0.64637977",
"0.6458492"
] |
0.80314225
|
0
|
Use callbacks to share common setup or constraints between actions.
|
def set_mission_membership
@mission_membership = MissionMembership.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 setup_handler\n end",
"def before_actions(*logic)\n self.before_actions = logic\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 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 workflow\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 setup\n # override and do something appropriate\n end",
"def after_actions(*logic)\n self.after_actions = logic\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 startcompany(action)\n @done = true\n action.setup\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 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\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup(&block)\n define_method(:setup, &block)\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 init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\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 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 setup\n #implement in subclass;\n end",
"def after_set_callback; 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 setup(easy)\n super\n easy.customrequest = @verb\n end",
"def save_action; 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 setup(&blk)\n @setup_block = blk\n end",
"def default_action; end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); 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",
"def call\n setup_context\n super\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end"
] |
[
"0.6165094",
"0.60450804",
"0.5944413",
"0.5915806",
"0.58885634",
"0.5835225",
"0.5775847",
"0.5700531",
"0.5700531",
"0.56543404",
"0.56209993",
"0.54238355",
"0.5410386",
"0.5410386",
"0.5410386",
"0.5394892",
"0.5377769",
"0.53559244",
"0.5339896",
"0.53388095",
"0.5330087",
"0.5311993",
"0.5297402",
"0.5296789",
"0.52957207",
"0.52596015",
"0.5245442",
"0.5237084",
"0.5237084",
"0.5237084",
"0.5237084",
"0.5237084",
"0.5235431",
"0.5231888",
"0.5226663",
"0.52220625",
"0.5217086",
"0.52137345",
"0.5208314",
"0.5205469",
"0.5175606",
"0.5174914",
"0.5173361",
"0.51662856",
"0.5161792",
"0.51572216",
"0.5153063",
"0.5152982",
"0.5152632",
"0.51435786",
"0.5139829",
"0.51346594",
"0.511372",
"0.511372",
"0.51136476",
"0.51083213",
"0.5108011",
"0.5091935",
"0.5089297",
"0.5081576",
"0.50807106",
"0.50656676",
"0.50548106",
"0.50537366",
"0.505074",
"0.505074",
"0.5033361",
"0.5025158",
"0.5020441",
"0.5015611",
"0.50142473",
"0.5000281",
"0.50001067",
"0.49989453",
"0.4989465",
"0.4989465",
"0.4985425",
"0.49805096",
"0.49795893",
"0.49783278",
"0.49676263",
"0.49656346",
"0.49579078",
"0.4955427",
"0.49554235",
"0.49536413",
"0.49523768",
"0.49457142",
"0.49433607",
"0.4933641",
"0.49320185",
"0.49265638",
"0.49262375",
"0.49259067",
"0.4922456",
"0.49201223",
"0.49165115",
"0.49158815",
"0.49151883",
"0.49149552",
"0.4914386"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def mission_membership_params
params.require(:mission_membership).permit(:user_id, :mission_id)
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 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 valid_params_request?; 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 strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\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 url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\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 filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\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 reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\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 origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\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 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",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] |
[
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",
"0.62894756",
"0.6283177",
"0.6242471",
"0.62382483",
"0.6217549",
"0.6214457",
"0.6209053",
"0.6193042",
"0.6177802",
"0.6174604",
"0.61714715",
"0.6161512",
"0.6151757",
"0.6150663",
"0.61461",
"0.61213595",
"0.611406",
"0.6106206",
"0.6105114",
"0.6089039",
"0.6081015",
"0.6071004",
"0.60620916",
"0.6019971",
"0.601788",
"0.6011056",
"0.6010898",
"0.6005122",
"0.6005122",
"0.6001556",
"0.6001049",
"0.59943926",
"0.5992201",
"0.59909594",
"0.5990628",
"0.5980841",
"0.59669393",
"0.59589154",
"0.5958826",
"0.5957911",
"0.5957385",
"0.5953072",
"0.59526145",
"0.5943361",
"0.59386164",
"0.59375334",
"0.59375334",
"0.5933856",
"0.59292704",
"0.59254247",
"0.5924164",
"0.59167904",
"0.59088355",
"0.5907542",
"0.59064597",
"0.5906243",
"0.5898226",
"0.589687",
"0.5896091",
"0.5894501",
"0.5894289",
"0.5891739",
"0.58860534",
"0.5882406",
"0.587974",
"0.58738774",
"0.5869024",
"0.58679986",
"0.5867561",
"0.5865932",
"0.5864461",
"0.58639693",
"0.58617616",
"0.5861436",
"0.5860451",
"0.58602303",
"0.5854586",
"0.58537364",
"0.5850427",
"0.5850199"
] |
0.0
|
-1
|
I worked on this challenge with Gabrielle Gustilo. I spent 1 hours on this challenge. Complete each step below according to the challenge directions and include it in this file. Also make sure everything that isn't code is commented. 0. Pseudocode Input: An array of values. Output: An array of the most frequent values. Pseudocode: define method mode, which takes one argument "array" create new Hash iterate through the array if element is not a key in the Hash, create key with value +1 if element is a key in the Hash, increment value +1 get max value of hash check hash for other occurences of max value return as hash pull keys for max value hash 1. Initial Solution
|
def mode(array)
results = {}
array.each do |e|
if results.has_key?(e)
results[e] += 1
else
results[e] = 1
end
end
max = results.max_by{|k,v| v}
results.select!{|k,v| v == max[1]}
results.keys
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def mode(array)\n frequency = {}\n array.each do |item|\n if frequency.has_key?(item)\n frequency[item] = frequency[item] + 1\n else\n frequency[item] = 1\n end\n end\n\nmax_value = 0\nfrequency.each_value do |value|\n if value > max_value\n max_value = value\n end\nend\nmax = []\nmax_key = \"\"\nmax_freqency = []\nfrequency.each do |key, value|\n if value >= max_value\n max_value = value\n max_key = key\n max_freqency << max_key\n end\nend\nmax_freqency\nend",
"def mode(array)\n hash = Hash.new {|hash,key| hash[key] = 0} #creates a default value of 0 for all hash values\n\n array.each {|num| #iterate through the array and count +1 for each value\n hash[num] += 1\n }\n\n\n\n values = [] # Declare array of all values\n hash.each do |key, value|\n values.push(value)\n end\n\n\nmax_value = values.max #find the key with the maximum value\nresult = [] # Declare array where we return result\n\nhash.each do |key, value|\n if value == max_value\n result.push(key)\n end\nend\n return result\nend",
"def mode(array)\n freq_hash = Hash.new(0)\n #hash_array = Hash[array.map{|x| [x,0]}]\n array.each do |arg|\n freq_hash[arg] += 1\n end\n freq_hash\n new_array = Array.new\n\n freq_hash.each do |key,value|\n if value == freq_hash.values.max\n new_array.push(key)\n end\n end\n new_array\nend",
"def mode (array)\n # -make a hash to keep track of each item's frequecy\n tracker = {}\n# -iterate through the input array\n array.each do |x|\n# -create a key for each different thing in the input array\n if tracker.has_key?(x) # use the value to keep track of how often each thing shows up\n #increment the value up by 1\n tracker[x] += 1\n puts \"#{x} is incrementing\"\n else\n #add it\n tracker[x] = 1\n puts \"#{x} is being set\"\n end \n # -check the most frequent value \n \n puts \"tracker hash is like this: #{tracker}\"\n \n end \n puts \"array.each part done\"\n \n final_values = tracker.values\n highest = 0\n final_values.each do |x|\n if x > highest\n highest = x\n end \n \n end\n puts \"highest is #{highest}\"\n \n \n # find all the highest values and put em in an array\n output = []\n tracker.each do |key, value|\n if value == highest\n output << key\n end\n \n end\n return output\nend",
"def mode(array) \n hash = Hash.new(0) \n array.each do |x| \n hash[x] += 1\n end\n mode_array = []\n hash.each do |k,v|\n if v == hash.values.max\n mode_array << k\n end\n end\n mode_array\nend",
"def mode(array)\n new = Hash.new()\n array.each do |item|\n if new.has_key?(item)\n new[item] +=1\n else\n new[item] = 1\n end\n end\n mode = []\n freq = new.values.max\n new.each do |key,value|\n if freq==value\n mode.push(key)\n end\n end\n return mode\nend",
"def mode(array)\n hash = Hash.new {|hash,key| hash[key] =0}\n array.each do |item|\n hash[item] = array.count(item)\n end\n array2 = []\n hash.each do |k, v|\n if v == hash.values.max\n array2 << k\n end\n end\n array2\nend",
"def mode(array)\n mode_hash = Hash.new\n array.each {|x| mode_hash[x] = 0}\n mode_hash.each do |k,v| \n mode_hash[k] = array.count(k)\n end \n new_array = []\n mode_hash.each do |k, v|\n if v == mode_hash.values.max; new_array << k\n end\n end\n return new_array\nend",
"def mode(array)\n\n mode_hash = Hash.new\n for x in 0..(array.length - 1)\n if mode_hash.has_key?(array[x]) == true\n mode_hash[array[x]] = mode_hash[array[x]] + 1\n else\n mode_hash[array[x]] = 1\n end\n puts mode_hash\n end\n\n max_val = 0\n output_array =[]\n\n mode_hash.each do |key, value|\n\n if value > max_val\n output_array = []\n output_array[0] = key\n max_val = value\n\n elsif value == max_val\n\n output_array[output_array.length] = key\n max_val = value\n end\n end\n return output_array\nend",
"def mode(array)\n hash = Hash.new {|hash,key| hash[key] =0}\n array.each do |item| \n hash[item] = array.count(item)\n end\n array2 = []\n hash.each do |k, v| \n if v == hash.values.max\n array2 << k\n end\n end\n p array2\n end",
"def mode(array)\n hash = {}\n\n for i in 0...array.length\n count = 0\n current_element = array[i]\n for i in 0...array.length\n if current_element == array[i]\n count += 1\n else\n end\n hash[current_element] = count\n end\n end\n max_array = []\n hash.each {|key, value| (max_array.push(key)) if value == hash.values.max }\n return max_array\n\nend",
"def mode(array)\n mode_array = []\n counter = Hash.new(0)\n array.each do |x|\n counter[x] += 1 \n end\n counter.each do |k, v|\n if v == counter.values.max\n mode_array.push(k)\n end\n end\n return mode_array\nend",
"def mode(array)\n freq = Hash.new(0)\n\n array.each do |i|\n freq[i] += 1\n end\n\n temp = Array.new\n largest = 0\n\n freq.each do |k, v|\n if(v > largest)\n temp.clear\n temp.push(k)\n largest = v\n elsif(v == largest)\n temp.push(k)\n end\n end\n\n return temp\nend",
"def mode (array)\n hash = Hash.new (0)\n array.each { |item|\n hash[item] += 1}\n hash\n\n frequency = hash.values.max\n new_array = []\n\n hash.each { |key, value|\n if frequency == value\n new_array.push(key)\n end}\n new_array\nend",
"def mode (array) \n# creates a hash(tracker) with items as keys and frequencies as values\n tracker = {} \n array.each do |x| \n if tracker.has_key?(x) \n tracker[x] += 1\n else\n tracker[x] = 1\n end \n end \n# finds the highest value (frequency)\n final_values = tracker.values\n highest = 0 \n final_values.each do |x|\n if x > highest\n highest = x\n end \n end\n# adds each key (item) with the highest value to the output array\n output = []\n tracker.each do |key, value|\n if value == highest\n output << key\n end\n end\n return output\nend",
"def mode(array)\n\n data = Hash.new\n\n while array.length > 0\n frequency = array.count(array[0])\n\n data[array[0]] = frequency\n array.delete(array[0])\n end\n# p array\n data\n data.each do |k, v|\n array << k if v == data.values.max\n end\n p array\nend",
"def mode(array)\n frequency = Hash.new(0)\n array.each do |x|\n frequency[x] += 1\n end\n mode_array = []\n frequency.each do |y, z|\n if z == frequency.values.max\n mode_array << y\n end\n end\n mode_array.sort\nend",
"def mode(array)\n hash = {}\n array.each do |x| \n if !hash.has_key?(x)\n \thash[x] = 1\n else\n hash[x] += 1\n end \n end\n array_new = []\n max_value = hash.values.max\n hash.each do |key, value|\n if value == max_value\n array_new.push(key)\n end \n end\n return array_new\nend",
"def mode array\n freq = Hash.new(0)\n array.each do |num|\n freq.store(num, freq[num]+1)\n end\n target = []\n freq.each do |k,v|\n if v == freq.values.max\n target << k\n end\n end\n target\n \nend",
"def mode(array)\n count = Hash.new 0\n array.each do |n|\n count[n] += 1\n end\n\n frequency = count.values.max\n \n x = []\n count.each do |k, v|\n if frequency == v \n x.push k\n end\n end\n x\nend",
"def mode (array) \n# creates a hash(tracker) with items as keys and frequencies as values\n tracker = {} \n array.each do |x| \n if tracker.has_key?(x) \n tracker[x] += 1\n else\n tracker[x] = 1\n end \n end \n\n# adds each key (item) with the max value to the output array\n output = []\n tracker.each do |key, value|\n if value == tracker.values.max\n output << key\n end\n end\n\n return output\nend",
"def mode(array)\n container = []\n final = []\n h = Hash.new(0)\n array.each {|object| h[object] += 1}\n h.each do |key, value|\n container << value\n end \n highest = container.max\n h.each do |key, value| \n if value == highest\n final << key\n end\n end\n final\nend",
"def mode(array)\n freq = Hash.new\n array.each do |x|\n if freq[x].nil?\n freq[x] = 1\n else freq[x] += 1\n end\n end\n max = 0\n freq.each do |x, y|\n if y >= max\n max = y\n end\n end\n most = freq.select {|x, y| y == max}\n most.keys\nend",
"def mode(array)\n instance = Hash.new(0)\n array.each do |item|\n instance[item] += 1\n end\n most_frequent = instance.values.max\n p instance.collect { |k, v| k if v == most_frequent }.compact\nend",
"def mode(array)\n hash = Hash.new(0)\n array.each do |x|\n if hash.has_key?(x) == true\n hash[x] += 1\n else\n hash[x] = 1\n end\n end\n hash.select{|k,v| v == hash.values.max}.keys\nend",
"def mode(array)\r\n new_hash = Hash.new(0)\r\n output = []\r\n \r\n array.each do |i|\r\n new_hash[i] += 1\r\n end\r\n \r\n new_hash.each do |i, j| \r\n if new_hash.values.max == j\r\n output << i\r\n end\r\n end\r\n output\r\nend",
"def mode(array)\n hash = Hash.new(0)\n array.each { |key| hash[key] += 1}\n max_value = hash.values.max\n output_array = hash.select { |key, value| value == max_value }.keys\n output_array\nend",
"def mode(array)\n freq = Hash.new\n array.each do |x|\n if freq[x].nil?\n freq[x] = 1\n elsif freq[x] >= 1\n freq[x] += 1\n end\n end\n max = 0\n freq.each do |x, y|\n if y != nil && y >= max\n max = y\n end\n end\n most = freq.select {|x, y| y == max}\n most.keys\nend",
"def mode(array)\n hash = {}\n \tarray.each do |item|\n \t\tif hash[item]\n \t\thash[item] = hash[item] + 1\n \t\telse\n \t\thash[item] = 1\n \t\tend\n \tend\n \tmax_value = hash.values.max\n\thash.select {|k, v| k if (v == max_value)}.keys\n\nend",
"def mode(array)\n hash = Hash.new(0)\n array.each {|item| hash[item] += 1}\n answer = hash.max_by {|key, value| value}\n p answer\nend",
"def mode(array)\n\thash = Hash.new(0)\n \t\tarray.each do |i|\n \t\thash[i] += 1\n \tend\n\tfinal_array = []\n \tn = 0\n \tfrequent_value = hash.values[0]\n \twhile n < hash.length\n\t\tif frequent_value < hash.values[n]\n \t\tfrequent_value = hash.values[n]\n \tend\n \tn += 1\n \tend\n \thash.each do |key, val|\n \tif val == frequent_value\n \t\tfinal_array.push(key)\n \tend\n \tend\n \tp final_array\nend",
"def mode(array)\n counter = array.inject(Hash.new(0)) {|hash, key| hash[key] += 1; hash }\n new_array = []\n counter.each do |k, v|\n if v == counter.values.max\n new_array << k\n end\n end\n return new_array\nend",
"def mode(arr)\n counter = Hash.new(0)\n arr.each{|key| counter[key] += 1}\n solution = []\n counter.select {|key, value| solution << key if value == counter.values.max}\n p solution\nend",
"def mode(array)\n\n mode_hash = {}\n mode_array = []\n max = 0\n\n array.each do |element|\n\n if mode_hash.has_key?(element)\n mode_hash[element] += 1\n else\n mode_hash.store(element, 1)\n end\n end\n\n mode_hash.each do |key,value|\n if value > max\n max = value\n mode_array.clear\n mode_array.push(key)\n elsif value == max\n mode_array.push(key)\n else\n end\n end\n return mode_array\n end",
"def mode array\n hash = Hash.new(0)\n array.each do |x|\n hash[x] += 1\n end\n new_array=Array.new\n hash.each do |key, value|\n if value == hash.values.max\n new_array << key\n end\n end\n return new_array\nend",
"def mode(array)\n frequency = Hash.new(0)\n\tarray.each do |key|\n\t\tfrequency[key] +=1\n\tend\n\tmode = []\n\tfrequency.each do |k, v|\n if k == frequency.values.max\n mode << v\n end\n end\n\treturn mode\nend",
"def mode(array)\n\thash = Hash.new{|key, value| key[value] = 0}\n\thash[1]\n\tarray.each do |number|\n\t\thash[number] += 1\n\t\tend\n\t\tarray = []\n\thash.each do |key, value| \n\t\tif value == hash.values.max\n\t\tarray.push(key)\n\tend\n\tend\n\tp array\nend",
"def mode(array)\n create_hash = {}\n array.each {|x| create_hash[x] = 0}\n array.each {|x| create_hash[x] += 1}\n\n new_array = create_hash.max_by {|x,y| y\n }\n value_we_want = new_array[1]\n mode_container = []\n create_hash.each do |key, value|\n if value == value_we_want\n mode_container << key\n end\n end\nreturn mode_container\n\nend",
"def mode(array)\n frequency = Hash.new\n array.each do |x|\n array.count(x)\n frequency[x] = array.count(x)\n end\n\n most_frequent = Array.new\n max = frequency.max_by { |x, y| y}\n min = frequency.min_by { |x, y| y}\n if min == max\n frequency.each do |x,y| \n most_frequent = most_frequent.push(x)\n end\n else\n most_frequent[0] = max[0]\n end\n return most_frequent\nend",
"def mode(ary)\n mode_count = ary.inject({}){|x, y| x[y] = ary.count(y); x }\n mode_count.select {|x,y| y == mode_count.values.max }.keys\nend",
"def mode(array)\n h = array.each_with_object(Hash.new(0)) do |item, list|\n list[item] += 1\n end\n a = []\n h.each {|k, v| a.push(k) if v == h.values.max}\n a\nend",
"def mode(array)\n hash = Hash.new(0)\n array.each do |x|\n hash[x] += 1\n end\n result = []\n hash.each { |x,y|\n if y == hash.values.max\n result.push(x)\n end\n }\n return result\nend",
"def mode(arr)\n\th = {}\n\tarr.each do |x| \n\t\th [x] = arr.count(x)\n\tend\n\tarr = h.values.sort\n highest_count = arr.last\n h.select {|k,v| v == highest_count}.keys\nend",
"def mode(array)\n freq = {}\n array.each do |item|\n if freq.include?(item)\n freq[item] += 1\n else\n freq[item] = 1\n end\n end\n \n return freq.select{|k,v| v==freq.values.max}.keys\nend",
"def mode(array)\n new_hash = Hash.new\n array.uniq.each {|x| new_hash[x] = 1}\n new_hash.each {|element, value| new_hash[element] = array.count(element)}\n max = 0\n new_hash.each {|key, value| max = value if value > max}\n new_hash.select! {|key, value| value == max}\n return new_hash.keys\nend",
"def mode(array)\n count = Hash.new(0)\n array.each {|element| count[element] += 1}\n max = count.values.max\n count.keep_if {|key,value| value == max}\n count.keys\nend",
"def mode(array)\n hash = Hash.new\n array.each do |x|\n quantity = array.count(x)\n hash[x] = quantity\n end\n mode_value = hash.values.max\n new_array= []\n hash.select do |key, value|\n if value == mode_value\n new_array.push(key)\n end\n end\n return new_array\nend",
"def mode(arr)\n count = Hash.new(0)\n arr.each { |value| count[value] += 1 }\n count = count.sort_by { |key, value| value }\n count.reverse!\n high = count[0][1]\n count.select! { |key, value| value == high } \n result = count.collect(&:first)\n result.sort!\nend",
"def mode(array)\n y = Hash.new(0)\n array.each do |x|\n y[x] += 1\n end\n\n new_array = y.select{|a, b| b == y.values.max}.keys\nend",
"def mode(array)\n table = Hash.new(0)\n for a in array\n table[a] = table[a] + 1\n end\n highest_freq = 0\n table.each do |k, v|\n if v > highest_freq\n highest_freq = v\n end\n end\n modes_hash = table.select{|k, v| highest_freq == v}\n modes = modes_hash.keys\nend",
"def mode(array) \n\th = Hash.new(0)\n\tarray.each do |x| \n\t\th[x] = h[x] + 1 \n\tend\n\th.select { |k,v| v == h.values.max }.keys\nend",
"def mode(arr)\n hash = Hash[arr.map {|x| [x, 0]}]\n arr.each do |item|\n if hash.has_key?(item)\n hash[item] += 1\n end\n end\n max = hash.values.max\n new_hash = Hash[hash.select { |k, v| v == max}]\n return new_hash.keys\nend",
"def mode(array)\n\tfrequency = Hash.new\n\n\tfor i in array\n\t\tfrequency[i] = array.count(i)\n\tend\n\n\tmost_frequent_key = frequency.values.max\n\tmode_list = []\n\n\tfor key, value in frequency\n\t\tif value == most_frequent_key\n\t\t\tmode_list << key\n\t\tend\n\tend\n\treturn mode_list\nend",
"def mode(arr)\n hash = arr.inject(Hash.new(0)) {|h, v| h[v] += 1; h}\n output = []\n hash.each {|k, v| output << k if v == hash.values.max}\n return output\nend",
"def mode(arr)\n hash = arr.inject(Hash.new(0)) {|h, v| h[v] += 1; h}\n output = []\n hash.each {|k, v| output << k if v == hash.values.max}\n return output\nend",
"def mode (array)\n newhash=Hash.new\n array.each do |x|\n newhash[x] = newhash[x].to_i + 1\n end\n modevalue = newhash.values.max\n modearray= Array.new\n newhash.each do |x, y|\n if y == modevalue\n modearray.push(x)\n end\n end\n return modearray\nend",
"def array_mode(array)\n new_array = Array.new\n freq = Hash.new\n max_count = 1\n\n array.each do |i|\n if freq.include? (i)\n freq[i] += 1\n if freq[i] > max_count\n max_count = freq[i]\n end\n else\n freq[i] = 1\n end\n end\n freq.each {|k,v| new_array.push(k) if v == max_count}\n new_array\nend",
"def mode(array)\n mode_hash = Hash.new(0)\n array.each {|n| mode_hash[n] += 1}\n max = mode_hash.values.max\n output_array = mode_hash.map {|k, v| if v == max then k end} \n p output_array.compact\nend",
"def mode(array)\n h = Hash.new\n num = 0\n largest = 0\n while num < array.length\n h[array[num]] = array.count(array[num])\n num = num + 1\n end\n max_quantity = h.values.max\n max_h = h.select { |k, v| v == max_quantity }.keys\n p max_h\nend",
"def mode(array)\n\tvals = {}\n\tmode_vals = []\n\tarray.each {|x|\n\t\tif vals.include? x \n\t\t\tvals[x] += 1\n\t\telse\n\t\t\tvals[x] = 1\n\t\tend\n\t}\n\t#hash.values puts values in array. array.max returns the max!\n\tmax = vals.values.max\n\tvals.each {|key,value| \n\t\tmode_vals.push(key) if value == max\n\t}\n\tmode_vals\nend",
"def mode(array)\n mode = array.inject(Hash.new(0)) { |i,x| i[x] = i[x] + 1; i}\n mode.select{ |i,x| x == mode.values.max }.keys\nend",
"def mode(array)\n count = Hash.new(0) \n array.each do |x| count[x] += 1 end #counts number of occurences and stores in count hash\n \n if array == array.uniq # if array values occur equally, return array\n array\n else\n array.keep_if{\n \t|x| array.count(x) >= count.values.max #keep all values that occur same number of times as highest count{} frequency\n \t}.uniq!\n end\nend",
"def mode(array)\n count = Hash.new(0) \n array.each do |x| count[x] += 1 end\n max_val = count.values.max\n puts max_val\n if array == array.uniq\n return array\n else\n array1 = array.keep_if do |x| array.count(x) >= count.values.max end\n array1.uniq!\n end\n \nend",
"def mode(array)\n new_array = []\n words_freq = {}\n max = 0\n array.each do |i|\n if words_freq.include?(i)\n words_freq[i] += 1\n else\n words_freq[i] = 1\n end\n\n if max < words_freq[i]\n max = words_freq[i]\n end\n end\n\n words_freq.each do |key, value|\n new_array << key if value == max\n end\n return new_array\nend",
"def mode(array)\n\tfrequencies = Hash.new(0)\n\tarray.each { |array_object| frequencies[array_object]+=1 }\n\tfrequencies = frequencies.select { |key,value| value>= frequencies.values.max }\n\tmode_array = []\n\tfrequencies.each_key {|key| mode_array << key}\n\treturn mode_array\nend",
"def mode(array)\n hash = Hash.new(0)\n num_a = []\n final_a = Array.new\n\n array.each do |value|\n hash[value] += 1\n end\n\n num_a = hash.values.sort\n\n hash.each do |k,v|\n if v == num_a[-1]\n final_a << k\n end\n end\n\n return final_a\nend",
"def mode(array)\n\thash = Hash.new(0)\n\tarray.each {|item| hash[item] += 1 if hash[item] != nil}\n\n\tnew_array = []\n\tmax_value = hash.values.max\n\thash.each { |k, v| new_array.push(k) if hash[k] == max_value}\n\tp new_array\nend",
"def mode(input_array)\n counts = Hash.new\n\n # i=0\n # while i < input_array.length\n # if counts.has_key?(input_array[i])\n # counts[input_array[i]]+=1\n # else\n # counts[input_array[i]]=1\n # end\n # i+=1\n # end\n\n input_array.each do |element|\n if counts.has_key?(element)\n counts[element]+=1\n else\n counts[element]=1\n end\n end\n\n # puts counts\n\n max=0\n\n counts.each do |word,count|\n if count > max\n max = count\n end\n end\n\n # puts max\n\n output_array = Array.new\n\n counts.each do |word,count|\n if count == max\n output_array.push(word)\n end\n end\n\n p output_array\n\nend",
"def mode(numbers)\n counts = {}\n numbers.each do |num|\n if counts.has_key?(num)\n counts[num] = counts[num] + 1\n else\n counts[num] = 1\n end\n end\n\n num_list = counts.values\n highest_count = num_list.max\n\n modes = []\n counts.each do |key, count|\n if count == highest_count\n modes.push(key)\n end\n end\n return modes\nend",
"def mode(array)\n\tvals = {}\n\tmode_vals = []\n\tarray.each {|element|\n\t\tif vals.include? element \n\t\t\tvals[element] += 1\n\t\telse\n\t\t\tvals[element] = 1\n\t\tend\n\t}\n\tmax = vals.values.max\n\tvals.each {|key,value| \n\t\tmode_vals.push(key) if value == max\n\t}\n\tmode_vals\nend",
"def mode(array)\n pad_hash = Hash.new(0)\n \n array.each do |index|\n pad_hash[index] += 1\n end\n \n pad_array = []\n pad_hash.each {|k, v| if v == pad_hash.values.max then pad_array.push k end}\n\n p pad_array\nend",
"def mode(input_array)\n counts = Hash.new\n input_array.each do |element|\n if counts.has_key?(element)\n counts[element] += 1\n else\n counts[element] = 1\n end\n end\n\n max = 0\n counts.each do |key, value|\n if value > max\n max = value\n end\n end\n\n output_array = Array.new\n counts.each do |word, count|\n if count == max\n output_array.push(word)\n end\n end\n return output_array\nend",
"def mode(array)\n frequencies = Hash.new(0)\n new_array = []\n array.each do |num|\n frequencies[num] += 1\n end\n frequencies = frequencies.sort_by {|a, b| b }.to_h\n modes = frequencies.values.last\n frequencies = frequencies.select {|k, v| v == modes}\n frequencies.each do |key, value|\n new_array.push(key)\n end\n new_array = new_array.sort\n p new_array\nend",
"def mode(array)\n mode_machine = Hash.new(0)\n array.each do |element|\n mode_machine[element] += 1\n end\n highest_count = 0\n mode_container = []\n mode_machine.each do |element, count|\n mode_container << element if count == highest_count\n if count > highest_count\n mode_container = []\n mode_container << element\n highest_count = count\n end\n end\n mode_container\nend",
"def mode(original_array)\n frequency = Hash.new(0)\n original_array.each{ |i| frequency[i] += 1}\n new_array = frequency.max_by { |x,y| y }\n mode_solution = new_array[1]\n result = []\n frequency.each do |key,value|\n if value == mode_solution\n result << key\n end\n end\n return result\nend",
"def mode(input_array)\n\n counts = Hash.new(0)\n input_array.each do |element|\n counts[element] += 1\n end\n\n output_array = Array.new\n\n counts.each do |word, count|\n if count == counts.values.max\n output_array << word\n end\n end\n\n return output_array\n\nend",
"def mode(array)\n mode_hash = Hash.new\n array.each do |x|\n if mode_hash.has_key?(x)\n mode_hash[x] += 1\n else\n mode_hash[x] = 1\n end\n end\n a = mode_hash.values.sort.last\n answer_array = []\n mode_hash.each do |key, value|\n if value == a\n answer_array << key\n end\n end\n\n return answer_array\n\nend",
"def mode(array)\n hash = Hash.new(0)\n new_array = []\n\n array.each do |i|\n hash[i] += 1\n end\n\n hash = hash.sort_by { |key, value| value }.reverse.to_h\n\n hash.each do |key, value|\n if value == hash.values[0]\n new_array << key\n end\n end\n p new_array\nend",
"def mode(array)\n frequencies = array.each_with_object(Hash.new(0)) { |word, count| count[word] += 1 }\n mode_array = frequencies.select { |frequent_words, frequent_counts| frequent_counts == frequencies.values.max }.keys\n return mode_array\nend",
"def mode(array)\n count = {}\n modes = []\n\n array.each do |el|\n count[el] = count[el].to_i + 1\n end\n\n most = count.invert.sort.to_a.last.first\n count.each_pair do |x, y|\n modes << x if y == most\n end\n\n return modes\nend",
"def mode(arr)\n\tarr.sort!\n\tfreq_val = Hash.new(0)\n\tarr.each{ |i|\n\t freq_val[i] += 1 }\n\t freq_val.sort_by { |k,v| v}\n\t return freq_val.values[0]\nend",
"def mode(array)\n mode_hash = Hash.new\n array.each do |x|\n if mode_hash.has_key?(x)\n mode_hash[x] += 1\n else\n mode_hash[x] = 1\n end\n end\n a = mode_hash.values.sort.last\n answer_array = []\n x = mode_hash.select { |key, value| value == a}\n answer_array = x.keys\n return answer_array\nend",
"def mode (array)\n\tcounter = Hash.new(0)\n\tarray.each do |element| \n\t\tcounter[element] += 1\n\tend\n\n\tcounter.keep_if do |element,count| \n\t\tcount == counter.values.max \n\tend\n\n\treturn counter.keys\nend",
"def mode(a)\n b = Hash.new(0)\n final = []\n max = 1\n a.each do |x|\n b[x] +=1\n if b[x] >= max\n max = b[x]\n end\n end\n\n b.each do |x,y|\n if max == y\n final<< x\n end\n end\n return final\nend",
"def mode(array)\nfinal_array = []\nmax_count = []\narray.map do |r| \n max_count << array.count(r)\n end\n max_num = max_count.max\narray.map do |m|\n if array.count(m) == max_num\n final_array << m\n end\n end\n final_array.uniq\n\nend",
"def mode(array)\n h = Hash.new(0)\n array.each do |i| \n h[i] += 1\n end\n h.sort_by {|key, value| p value}\n key = h.keys[0]\n p key\n p Array.new(1, key)\n \nend",
"def mode\n freqh = frequency.inject(Hash.new(0)) { |h,v| h[v] += 1; h}\n\n freqh.select { |k, v| v == freqh.values.max}.keys\n end",
"def mode(input_array)\n output_mode = []\n mode_hash = {}\n\n input_array.each { |variable|\n if mode_hash.has_key?(variable)\n mode_hash[variable] += 1\n else\n mode_hash[variable] = 1\n end\n }\n\n output_mode = mode_hash.values.sort\n\n result = mode_hash.select { |k,v| \n v == output_mode[-1]\n }\n\n return result.keys\nend",
"def mode(values)\n\n new_array = []\n mode = values.inject(Hash.new(0)) {|k,v| k[v] +=1; k}\n current_smallest_value = mode[0]\n\n mode.each_value do |v|\n if v > current_smallest_value\n current_smallest_value = v\n end\n end\n\n mode.each_pair do |k,v|\n if v >= current_smallest_value\n new_array << k\n end\n end\n p new_array\nend",
"def mode()\n counts = Hash.new(0)\n self.each { |elt| counts[elt] += 1 }\n return nil if counts.empty?\n max_val = counts[self[0]]\n max_key = self[0]\n\n counts.each do |elt,count|\n if count > max_val\n max_val = count\n max_key = elt\n end\n end\n max_key\n end",
"def mode(list)\n my_hash = {}\n list.each do |item| \n if my_hash[item]\n my_hash[item] += 1\n else\n my_hash[item] = 1\n end\n end\n max_count = my_hash.values.max\n my_hash.select { |key, value| value == max_count }.keys\nend",
"def mode(mode)\n mode_return = mode.inject({}) { |k, v| k[v] = mode.count(v); k }\n mode_return.select { |k,v| v == mode_return.values.max }.keys\nend",
"def mode(mode)\n mode_return = mode.inject({}) { |k, v| k[v] = mode.count(v); k }\n mode_return.select { |k,v| v == mode_return.values.max }.keys\nend",
"def mode(mode)\n mode_return = mode.inject(Hash.new()) do |key, value|\n \tkey[value] = mode.count(value);\n \tkey\n end\n mode_return.select {|key, value| value == mode_return.values.max}.keys\nend",
"def mode \n frequency_count = reduce(Hash.new(0)) { |freq, value| freq[value] += 1; freq}\n mode_count = frequency_count.values.max\n mode = frequency_count.select { |key, value| value == mode_count } # Select mode pairs\n return mode.keys.max # In case of multi-modes, return largest\n end",
"def mode(array)\n\thash = array.group_by{|i|i}\n\tnew_array = hash.sort_by {|key,value| \n\t\t-value.size\n\t}\n\ti = new_array[0][1].size\n\tmode_array = []\n\tnew_array.each {|value|\n\t\tif value[1].length == i\n\t\t\tmode_array << value\n\t\tend\n\t}\n\tfinal = mode_array.map{|value| value[1]}\n\tfinal.flatten.uniq.sort\nend",
"def mode array\n greatestRepeats = 0\n frequent = []\n array.each do |current|\n totalCurrent = array.count current\n puts \"For \" + current.to_s + \" we have found: \" + totalCurrent.to_s + \" repeats\"\n if totalCurrent > greatestRepeats\n counter = 0\n while frequent.length > 0 #wipe frequent\n frequent.delete(counter)\n counter += 1\n end\n greatestRepeats = totalCurrent\n frequent.push current\n elsif totalCurrent == greatestRepeats && totalCurrent > 0 #add without wiping frequent\n frequent.push current\n end\n end\n\n frequent.uniq\nend",
"def mode (array)\n number_count = 0\n\n array.each do |value| \n if array.count(value) > number_count\n number_count = array.count(value)\n end\n end\n\n new_array = []\n array.each do |value| \n if array.count(value) == number_count\n new_array << value\n end\n end\n return new_array.uniq\nend",
"def mode(items)\n keys = items.uniq\n occurences = Hash.new\n\n keys.each do |element|\n occurences[element] = items.count { |item| item == element }\n end\n\n count = 0\n mode = []\n occurences.each do |key, value|\n if value > count\n mode[0], count = key, value\n end\n end\n\n occurences.each do |key, value|\n if value == count && !mode.include?(key)\n mode << key\n end\n end\n\n mode\nend",
"def mode array\n\tmode_array = Hash.new(0)\n\tarray.each{ |i| mode_array[i] +=1}\n\tmode_array = mode_array.sort_by{|a,b| b}\n\tmode_array.reverse!\n\treturn mode_array[0]\nend"
] |
[
"0.89550817",
"0.8930741",
"0.88528234",
"0.8817719",
"0.87976265",
"0.87596524",
"0.87591493",
"0.874088",
"0.8733053",
"0.8720825",
"0.87126374",
"0.86996806",
"0.8682977",
"0.86768436",
"0.8663148",
"0.866122",
"0.86584437",
"0.86504096",
"0.8647628",
"0.864164",
"0.8628345",
"0.862655",
"0.86065954",
"0.8606411",
"0.85975057",
"0.8596383",
"0.8587303",
"0.8586117",
"0.8564993",
"0.8561538",
"0.85473704",
"0.8522362",
"0.8519959",
"0.8512853",
"0.8511114",
"0.8503802",
"0.8495073",
"0.8492415",
"0.84887195",
"0.84739006",
"0.8470635",
"0.846842",
"0.8463552",
"0.84605694",
"0.8460264",
"0.8438828",
"0.8435628",
"0.8421138",
"0.8418629",
"0.84182084",
"0.83967483",
"0.83882236",
"0.8381371",
"0.83795327",
"0.83795327",
"0.8372813",
"0.8371576",
"0.8371356",
"0.8320262",
"0.8312501",
"0.8305738",
"0.82931393",
"0.828124",
"0.8252213",
"0.8244393",
"0.8236056",
"0.8228757",
"0.8203946",
"0.8189772",
"0.8180335",
"0.8161591",
"0.81593627",
"0.81575143",
"0.81149006",
"0.8099859",
"0.809677",
"0.8062452",
"0.8059064",
"0.80574554",
"0.80333936",
"0.8028657",
"0.79996604",
"0.7981044",
"0.79776496",
"0.79749185",
"0.79168224",
"0.7912423",
"0.7900138",
"0.7890377",
"0.7865274",
"0.7856452",
"0.77164227",
"0.77164227",
"0.76826257",
"0.76574945",
"0.75981224",
"0.7596281",
"0.7591479",
"0.75567627",
"0.75444245"
] |
0.83049667
|
61
|
Dispatch remaining units in owned territories. Used when the user didn't do it himself during deployment.
|
def dispatch_remaining_units!
Participation.transaction do
shuffled_ownerships = ownerships.shuffle
1.upto(units_count) do
ownerships.sample.deploy_units!(1)
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def compute_free_places\n max_participants - compute_occupied_places\n end",
"def getAllUnits\n deep_copy(@allUnits)\n end",
"def completed_units\n return @completed_units\n end",
"def user_units\n @user.units\n end",
"def available_units\n return 0 if status == NO_SPACE\n\n 999\n end",
"def unit_workers\n world.units.active.find_all { |u|\n unit_isworker(u)\n }\n end",
"def allied_units\n @game.units.find_all { |u| u.faction == @faction }\n end",
"def get_sum_defender_units\n all_units = 0\n @defender_fleet.ship_groups.each do |group|\n all_units = all_units + group.number\n end\n return all_units\n end",
"def administrative_units\n return @administrative_units\n end",
"def selectable_units(user)\n return Unit.all.to_a if user.admin?\n\n units = []\n depts = []\n if division_edit_allowed?\n depts += PersonnelRequestPolicy.allowed_divisions(user).map(&:departments).flatten\n end\n\n if department_edit_allowed?\n depts += user.roles.map(&:department).compact.uniq\n depts.each do |d|\n units += Unit.where(department: d.id).to_a\n end\n end\n\n unit_edit_allowed? ? (units + user.roles.map(&:unit)).compact.uniq : units\n end",
"def party_worth\n get_worth_of( shared_inventory + actors_inventory )\n end",
"def unit_citizens\n world.units.active.find_all { |u| \n unit_iscitizen(u)\n }\n end",
"def foods_units\n get('/foods/units.json')\n end",
"def total_land_use\n return nil if [number_of_units, land_use_per_unit].any?(&:nil?)\n\n number_of_units * land_use_per_unit\n end",
"def units\n self.ListUnits.first.map { |u| map_unit(u) }\n end",
"def total_units\n return @total_units\n end",
"def reimburse_units(inventory_units)\n reimbursement = nil\n\n Spree::OrderMutex.with_lock!(@order) do\n return_items = inventory_units.map(&:current_or_new_return_item)\n reimbursement = Spree::Reimbursement.new(order: @order, return_items: return_items)\n reimbursement.return_all\n end\n\n reimbursement\n end",
"def current_occupancy\n self.dinosaurs.size\n end",
"def unload(units, planet)\n raise GameLogicError.new(\n \"You did not give any units to unload!\"\n ) if units.blank?\n\n transporter_location = location_point\n units.each do |unit|\n raise GameLogicError.new(\n \"Unit #{unit} must be in #{self}!\"\n ) unless unit.location == transporter_location\n raise GameLogicError.new(\n \"Unit #{unit} must not be hidden!\"\n ) if unit.hidden?\n end\n\n self.stored -= self.class.calculate_volume(units)\n save!\n\n update_transporter_units(units, planet.location_point)\n end",
"def update()\r\n\t\tto_remove = []\r\n for i in 0..@units.length-1\r\n @units[i].main()\r\n\t\t\tif @units[i].vie <= 0\r\n\t\t\t\tto_remove << @units[i]\r\n\t\t\t\t@units[i].die()\r\n\t\t\tend\r\n end\r\n\t\t@units -= to_remove\r\n end",
"def update\n if params[:unit][:parent_id].present? &&\n !policy(@unit).change_parent?(params[:unit][:parent_id])\n raise NotAuthorizedError,\"Cannot move a unit into a unit of \"\\\n \"which you are not an effective administrator.\"\n end\n begin\n ActiveRecord::Base.transaction do\n assign_administrators\n @unit.update!(unit_params)\n end\n rescue => e\n render partial: \"shared/validation_messages\",\n locals: { object: @unit.errors.any? ? @unit : e },\n status: :bad_request\n else\n RefreshOpensearchJob.perform_later\n toast!(title: \"Unit updated\",\n message: \"The unit \\\"#{@unit.title}\\\" has been updated.\")\n render 'shared/reload'\n end\n end",
"def units\n @units = SQF.units @this\n @units\n end",
"def get_units(dimension)\n nil\n end",
"def dwelling_units\n (household_units.collect(&:dwelling_units).flatten.compact +\n addresses.collect(&:dwelling_unit).flatten.compact).uniq\n end",
"def units\n return @units\n end",
"def units\n @formulation = (params[:formulation] || '').upcase\n drug = Drug.find_by_name(@formulation) rescue nil\n render plain: \"per dose\" and return unless drug && !drug.units.blank?\n render plain: drug.units\n end",
"def total_rent\n rent_array = self.locations.map do |location|\n location.rent\n end\n rent_array.inject(:+)\n end",
"def do_production(world)\n cs = self.consumes\n cs.each do |commodity, quantity|\n item = owner.consume(commodity, quantity, world)\n @production *= (item[:fulfilled].to_f / quantity.to_f).floor.to_i\n @running_cost += item[:price]\n end\n end",
"def units(units=nil)\n cur_page.units(units)\n end",
"def world_totals\n json_response('/totals')\n end",
"def households_supplied_per_unit\n fetch(:households_supplied_per_unit) { 1.0 }\n end",
"def total_annual_rent_collected\n units.map { |unit| unit.is_vacant ? 0 : unit.monthly_rent }.reduce(:+) * 12\n end",
"def units\n q = \"select distinct unit_id from master_files m inner join master_file_locations l on l.master_file_id=m.id\"\n q << \" where location_id = #{id}\"\n return Location.connection.query(q).flatten\n end",
"def total_rent\n #go through each location and add the rent property together\n restaurant_rent = 0\n self.locations.inject {|total_rent, ind_rent| restaurant_rent + location.rent}\n end",
"def total_units=(value)\n @total_units = value\n end",
"def turretUnit _obj, _args\n \"_obj turretUnit _args;\" \n end",
"def occupied_by\n @occupied_by\n end",
"def index\n areas = if current_user.moderator?\n ProductionArea.where.not(state: 0).eager_load(:map_layer)\n else\n current_user.production_areas.eager_load(:map_layer).with_translations(I18n.locale)\n end\n @cabinet_production_areas = areas\n end",
"def administrative_units=(value)\n @administrative_units = value\n end",
"def unit_members#(current_unit, current_staff, current_roles)\n #Academicians & Mgmt staff : \"Teknologi Maklumat\", \"Perpustakaan\", \"Kewangan & Akaun\", \"Sumber Manusia\",\"logistik\", \"perkhidmatan\" ETC.. - by default staff with the same unit in Position will become unit members, whereby Ketua Unit='unit_leader' role & Ketua Program='programme_manager' role.\n #Exceptional for - \"Kejuruteraan\", \"Pentadbiran Am\", \"Perhotelan\", \"Aset & Stor\" (subunit of Pentadbiran), Ketua Unit='unit_leader' with unit in Position=\"Pentadbiran\" Note: whoever within these unit if wrongly assigned as 'unit_leader' will also hv access for all ptdos on these unit staff\n\n current_staff=staff\n exist_unit_of_staff_in_position = Position.find(:all, :conditions => ['unit is not null and staff_id is not null']).map(&:staff_id).uniq\n if exist_unit_of_staff_in_position.include?(current_staff)\n\n current_unit=staff.position.unit #staff.positions.first.unit\n #replace current_unit value if academician also a Unit Leader (23)\n #current_roles=User.where(userable_id: userable_id).first.roles.map(&:name) ##\"Unit Leader\" #userable.roles.map(&:role_id)\n current_roles=roles.map(&:name)\n current_unit=unit_lead_by_academician if current_roles.include?(\"Unit Leader\") && Programme.roots.map(&:name).include?(current_unit)\n\n if current_unit==\"Pentadbiran\"\n unit_members = Position.find(:all, :conditions => ['unit=? OR unit=? OR unit=? OR unit=?', \"Kejuruteraan\", \"Pentadbiran Am\", \"Perhotelan\", \"Aset & Stor\"]).map(&:staff_id).uniq-[nil]+Position.find(:all, :conditions => ['unit=?', current_unit]).map(&:staff_id).uniq-[nil]\n elsif [\"Teknologi Maklumat\", \"Pusat Sumber\", \"Kewangan & Akaun\", \"Sumber Manusia\"].include?(current_unit) || Programme.roots.map(&:name).include?(current_unit)\n unit_members = Position.find(:all, :conditions => ['unit=?', current_unit]).map(&:staff_id).uniq-[nil]\n else #logistik & perkhidmatan inc.\"Unit Perkhidmatan diswastakan / Logistik\" or other UNIT just in case - change of unit name, eg. Perpustakaan renamed as Pusat Sumber\n unit_members = Position.find(:all, :conditions => ['unit ILIKE(?)', \"%#{current_unit}%\"]).map(&:staff_id).uniq-[nil]\n end\n else\n unit_members = []#Position.find(:all, :conditions=>['unit=?', 'Teknologi Maklumat']).map(&:staff_id).uniq-[nil]\n end\n unit_members #collection of staff_id (member of a unit/dept) - use in model/user.rb (for auth_rules)\n #where('staff_id IN(?)', unit_members) ##use in ptdo.rb (controller - index)\n end",
"def index\n @org_units = OrgUnit.all\n end",
"def index\n @first_level_units = FirstLevelUnit.active.order(:organization_id)\n end",
"def archival_units\n init_au_states(:all)\n # @collections = @archive.collections_filter_by_states(@states); \n @archival_units = @archive.archival_units_filter_by_states(@states); \n respond_to do |format|\n format.html { @archival_units = @archival_units} \n format.json { render :json=> @archival_units }\n format.xml { render :xml => ArchivalUnit.to_xml(:au_list => @archival_units, :skip_instruct => true) }\n end\n end",
"def total_owned\n self.shares.map{ |share| share.value }.inject(:+)\n end",
"def index\n @commercial_units = CommercialUnit.where(manager_id: current_manager.id)\n end",
"def completed_units=(value)\n @completed_units = value\n end",
"def remaining_production_total\n return productions_total - allotment_total_of_production_queue - allotment_total_of_research\n end",
"def unit_idlers\n world.units.active.find_all { |u|\n unit_isidler(u)\n }\n end",
"def index\n @workout_units = WorkoutUnit.all\n end",
"def number_of_units\n return 0.0 if demand.zero?\n return super unless full_load_hours&.positive?\n\n if input_capacity&.positive?\n demand / (input_capacity * full_load_hours)\n elsif output_capacity&.positive?\n (demand - output_of_loss) / (output_capacity * full_load_hours)\n else\n super\n end\n end",
"def get_units\n @agency, @depts = params[:agency], params[:dept]\n render :layout => false\n end",
"def remaining_total\n total\n end",
"def test_top_left_one_unit_per_floor_no_corridor\n num_finished_spaces = 1\n args_hash = {}\n args_hash['num_floors'] = 3\n args_hash['num_units'] = 3\n args_hash['level'] = 'Top'\n args_hash['corridor_position'] = 'None'\n args_hash['horz_location'] = 'Left'\n expected_num_del_objects = {}\n expected_num_new_objects = { 'BuildingUnit' => 1, 'Surface' => 6, 'ThermalZone' => 1, 'Space' => 1, 'SpaceType' => 1, 'PeopleDefinition' => num_finished_spaces, 'People' => num_finished_spaces, 'ScheduleConstant' => 1, 'ShadingSurfaceGroup' => 2, 'ShadingSurface' => 6, 'ExternalFile' => 1, 'ScheduleFile' => 1 }\n expected_values = { 'FinishedFloorArea' => 900 * 1, 'BuildingHeight' => 8, 'Beds' => 3.0, 'Baths' => 2.0, 'NumOccupants' => 3.39, 'EavesDepth' => 2, 'NumAdiabaticSurfaces' => 1 }\n _test_measure(nil, args_hash, expected_num_del_objects, expected_num_new_objects, expected_values, __method__)\n end",
"def current_subtotal\n debt_claim_items.reject(&:marked_for_destruction?).sum(&:current_debt)\n end",
"def remaining_milestones\n finish - milestone\n end",
"def number_of_units\n dataset_get(:number_of_units) || fetch(:number_of_units, false) do\n # #to_i also checks if it is nil\n if input_capacity.nil? || input_capacity.zero? ||\n full_load_hours.nil? || full_load_hours.zero?\n 0\n else\n used_capacity = input_capacity * capacity_to_demand_multiplier * full_load_hours\n (demand || preset_demand) / used_capacity\n end\n end\n end",
"def index\n @units = @gang.units.order( :id )\n @can_add_units = can_add_units\n end",
"def index\n if current_user\n @user = User.find(current_user.id)\n @uncompleted_items = Item.all - @user.items - completed_items\n else\n @uncompleted_items = Item.all - completed_items\n end\n end",
"def apply_guts_reduction\n if actor?\n guts_value = self.actor.guts_param\n # Value here should be subtracted\n guts_value += self.actor.guts_reduce\n self.actor.guts_param = [[guts_value, 0.0].max, guts_max].min\n end\n end",
"def occupied?\n not @unit.nil?\n end",
"def index\n @trunk_units = TrunkUnit.all\n end",
"def inventory_worth\n get_worth_of( shared_inventory )\n end",
"def index\n @rented_units = appointment.rented_units\n end",
"def scoped_computers(unit_id = nil)\n unit_id ||= @user.units\n Computer.where(:unit_id => unit_id)\n end",
"def tiles_remaining\n # still not sure why or how this is working. TODO: may take out later\n total_num_tiles = @default_set.inject(0) { |letter, letter_quantity| letter += letter_quantity[1] }\n p \"++++TEST++++\"\n p total_num_tiles\n return total_num_tiles\n end",
"def investors\n venture_capitalists = self.funding_rounds.map do |funding_round|\n funding_round.venture_capitalist\n end\n venture_capitalists.uniq\n end",
"def selected_units\n SQF.groupSelectedUnits @this\n end",
"def collect_treasure\n @gold_coins += 1\n if @gold_coins % 10 == 0\n level_up\n end\n end",
"def test_top_one_unit_per_floor_with_corridor\n num_finished_spaces = 1\n args_hash = {}\n args_hash['num_floors'] = 3\n args_hash['num_units'] = 3\n args_hash['level'] = 'Top'\n expected_num_del_objects = {}\n expected_num_new_objects = { 'BuildingUnit' => 1, 'Surface' => 6, 'ThermalZone' => 1, 'Space' => 1, 'SpaceType' => 1, 'PeopleDefinition' => num_finished_spaces, 'People' => num_finished_spaces, 'ScheduleConstant' => 1, 'ShadingSurfaceGroup' => 3, 'ShadingSurface' => 7, 'ExternalFile' => 1, 'ScheduleFile' => 1 }\n expected_values = { 'FinishedFloorArea' => 900 * 1, 'BuildingHeight' => 8, 'Beds' => 3.0, 'Baths' => 2.0, 'NumOccupants' => 3.39, 'EavesDepth' => 2, 'NumAdiabaticSurfaces' => 1 }\n _test_measure(nil, args_hash, expected_num_del_objects, expected_num_new_objects, expected_values, __method__)\n end",
"def occupation\n occupation_sum = 0\n team_roles.each do |team_role|\n occupation_sum += team_role.occupancy\n end\n return occupation_sum\n end",
"def getActiveCampuses\n return Unit.join(:unit_hier, :unit_id=>:id).\n filter(:ancestor_unit=>'root', :is_direct=>1).exclude(:status=>[\"hidden\", \"archived\"]).\n order_by(:ordering).to_hash(:id)\nend",
"def getActiveCampuses\n return Unit.join(:unit_hier, :unit_id=>:id).\n filter(:ancestor_unit=>'root', :is_direct=>1).exclude(:status=>[\"hidden\", \"archived\"]).\n order_by(:ordering).to_hash(:id)\nend",
"def organization_units\n if bind\n units = []\n AdOrganizationUnit.find_each do |local_entry|\n name = local_entry.distinguishedname.split(',')[0]\n units.push(name[3..name.length])\n end\n return units\n else\n return false\n end\n end",
"def portal_units_for(planet)\n player_id, ally_player_ids, planet_ids, ally_planet_ids =\n get_ids_from_planet(planet)\n volume = teleported_volume_for(planet)\n\n pick_units(\n player_id, planet_ids, ally_player_ids, ally_planet_ids, volume\n )\n rescue NoUnitsError\n []\n end",
"def unit_of_work\n Thread.current[:unit_of_work] || NoUnitOfWork\n end",
"def test_top_left_one_unit_per_floor_single_corridor\n num_finished_spaces = 1\n args_hash = {}\n args_hash['num_floors'] = 3\n args_hash['num_units'] = 3\n args_hash['level'] = 'Top'\n args_hash['corridor_position'] = 'Single Exterior (Front)'\n args_hash['horz_location'] = 'Left'\n expected_num_del_objects = {}\n expected_num_new_objects = { 'BuildingUnit' => 1, 'Surface' => 6, 'ThermalZone' => 1, 'Space' => 1, 'SpaceType' => 1, 'PeopleDefinition' => num_finished_spaces, 'People' => num_finished_spaces, 'ScheduleConstant' => 1, 'ShadingSurfaceGroup' => 3, 'ShadingSurface' => 7, 'ExternalFile' => 1, 'ScheduleFile' => 1 }\n expected_values = { 'FinishedFloorArea' => 900 * 1, 'BuildingHeight' => 8, 'Beds' => 3.0, 'Baths' => 2.0, 'NumOccupants' => 3.39, 'EavesDepth' => 2, 'NumAdiabaticSurfaces' => 1 }\n _test_measure(nil, args_hash, expected_num_del_objects, expected_num_new_objects, expected_values, __method__)\n end",
"def test_top_one_unit_per_floor_no_corridor\n num_finished_spaces = 1\n args_hash = {}\n args_hash['num_floors'] = 3\n args_hash['num_units'] = 3\n args_hash['level'] = 'Top'\n args_hash['corridor_position'] = 'None'\n expected_num_del_objects = {}\n expected_num_new_objects = { 'BuildingUnit' => 1, 'Surface' => 6, 'ThermalZone' => 1, 'Space' => 1, 'SpaceType' => 1, 'PeopleDefinition' => num_finished_spaces, 'People' => num_finished_spaces, 'ScheduleConstant' => 1, 'ShadingSurfaceGroup' => 2, 'ShadingSurface' => 6, 'ExternalFile' => 1, 'ScheduleFile' => 1 }\n expected_values = { 'FinishedFloorArea' => 900 * 1, 'BuildingHeight' => 8, 'Beds' => 3.0, 'Baths' => 2.0, 'NumOccupants' => 3.39, 'EavesDepth' => 2, 'NumAdiabaticSurfaces' => 1 }\n _test_measure(nil, args_hash, expected_num_del_objects, expected_num_new_objects, expected_values, __method__)\n end",
"def compute(object)\n return compute_for_inventory_units(object) unless object.inventory_units.empty?\n compute_for_line_items(object)\n end",
"def reduce_inventory\n Inventory.reduce_inventory(prize)\n end",
"def lift_totals\n lifters.sum do |lifter|\n lifter.lift_total\n end\n end",
"def units(by=nil)\n Unit.units.values.select { |unit| unit.dimensions == self }.map(&by).to_a\n end",
"def lift_total\n lifters.sum{|lifter| lifter.lift_total}\nend",
"def amount_of_ships(user, unit_id)\n \n return @attacker_fleet.ship_groups.find_by(unit_id: unit_id).number\n end",
"def inventory_for_longitudinal_presentation_unit_type_measurement\n inventories.map(& :quantity).inject(0) { |s,v| s += v } * packing_material.quantity\n end",
"def inventory_for_superficie_presentation_unit_type_measurement\n surface = packing_material.presentation_unit_type_measure.side_dimension_x * packing_material.presentation_unit_type_measure.side_dimension_y\n inventories.map(& :quantity).inject(0) { |s,v| s += v } * surface\n end",
"def investors\n self.funding_rounds.collect do |funding_round|\n funding_round.venture_capitalist\n end.uniq\n end",
"def transfer_unit\n if !params[:ic_number].nil?\n user = User.find_by_ic_number(params[:ic_number])\n departments = user.units.active.collect(&:name)\n render :json=>[departments] if departments\n end\n end",
"def test_top_left_two_unit_per_floor_no_corridor\n num_finished_spaces = 1\n args_hash = {}\n args_hash['num_floors'] = 3\n args_hash['num_units'] = 6\n args_hash['level'] = 'Top'\n args_hash['corridor_position'] = 'None'\n args_hash['horz_location'] = 'Left'\n expected_num_del_objects = {}\n expected_num_new_objects = { 'BuildingUnit' => 1, 'Surface' => 6, 'ThermalZone' => 1, 'Space' => 1, 'SpaceType' => 1, 'PeopleDefinition' => num_finished_spaces, 'People' => num_finished_spaces, 'ScheduleConstant' => 1, 'ShadingSurfaceGroup' => 2, 'ShadingSurface' => 6, 'ExternalFile' => 1, 'ScheduleFile' => 1 }\n expected_values = { 'FinishedFloorArea' => 900 * 1, 'BuildingHeight' => 8, 'Beds' => 3.0, 'Baths' => 2.0, 'NumOccupants' => 3.39, 'EavesDepth' => 2, 'NumAdiabaticSurfaces' => 2 }\n _test_measure(nil, args_hash, expected_num_del_objects, expected_num_new_objects, expected_values, __method__)\n end",
"def floors_available_and_curr_company_floors(company_id)\n total_available = floors_available + current_company_floors(company_id)\n total_available.sort!\n total_available\n end",
"def subtract_from_users_totals\n kwhs = self.average_daily_usage\n # users = UserHouse.joins(:house).where(house_id: house_id).select{|uh| (uh.move_in_date.to_datetime - 1) <= self.start_date}\n house = House.find(house_id)\n users = User.joins(:user_electric_bills)\n .where(:user_electric_bills => {electric_bill_id: id})\n .merge(house.users)\n elect_saved = self.electricity_saved.fdiv(no_residents)\n num_days = self.end_date - self.start_date\n users.each do |u|\n u.total_electricitybill_days_logged -= num_days\n u.total_kwhs_logged -= (total_kwhs.fdiv(no_residents))\n u.total_pounds_logged -= kwhs_to_carbon(kwhs)\n u.total_kwhs_logged.to_i == 0 ? clear_user_ranks(u) : nil\n u.total_pounds_logged.to_i == 0 ? clear_user_ranks_carbon(u) : nil\n u.total_electricity_savings -= elect_saved\n u.total_carbon_savings -= kwhs_to_carbon(elect_saved)\n u.save\n end\n house.update_data\n house.update_user_rankings\n end",
"def available_departments\n (active_departments + active_units.collect(&:parent)).uniq\n end",
"def units _args\n \"units _args;\" \n end",
"def nights\n checkout - checkin\n end",
"def units\n definitions = unit_counts\n\n units = []\n definitions.each do |type, count, flank|\n klass = \"Unit::#{type.camelcase}\".constantize\n count.times do\n unit = klass.new(:level => 1, :location => @planet, :flank => flank)\n unit.skip_validate_technologies = true\n\n units.push unit\n end\n end\n\n units\n end",
"def total_workout_calories\n set_sport_by_user.sum(:burned_calories) || 0\n end",
"def tiles_remaining\n @default_tiles.values.inject(0, :+)\n end",
"def units\n\t\tret = []\n\t\t@db.smembers('sgt-structure:' + @id + ':units').each do |uid|\n\t\t\tret.push(getUnit(@db, uid))\n\t\tend\n\t\tret\n\tend",
"def investors\n funding_rounds.map{|fr| fr.venture_capitalist}.uniq\n end",
"def actual_travel\n actual_travel = travel_expenses.reduce(0) {|sum, expense| sum += expense.amount }\n end",
"def after_ship\n inventory_units.each { |u| u.ship! if u.can_ship? && !u.state?('shipped') }\n end"
] |
[
"0.5652705",
"0.55627716",
"0.5475168",
"0.5465182",
"0.54602784",
"0.545765",
"0.54546475",
"0.54125816",
"0.53626484",
"0.53552467",
"0.53325886",
"0.53312206",
"0.53278375",
"0.53141254",
"0.52933687",
"0.5287663",
"0.52581763",
"0.52441067",
"0.5226708",
"0.52012277",
"0.5197255",
"0.51633346",
"0.51469994",
"0.51305807",
"0.5084852",
"0.50751114",
"0.50627935",
"0.50533605",
"0.50386935",
"0.50314295",
"0.50278753",
"0.50227714",
"0.5010265",
"0.50056446",
"0.5001712",
"0.5001537",
"0.49930146",
"0.49920017",
"0.49899426",
"0.49878958",
"0.4971435",
"0.49712935",
"0.49631947",
"0.49593028",
"0.49590063",
"0.49572816",
"0.4956981",
"0.49562722",
"0.49559495",
"0.49516797",
"0.49509043",
"0.49475557",
"0.49424314",
"0.4942324",
"0.4932621",
"0.49317366",
"0.4930583",
"0.4921946",
"0.49214235",
"0.49193445",
"0.49156564",
"0.4910894",
"0.4895237",
"0.48922953",
"0.48884204",
"0.48882854",
"0.48875314",
"0.48849458",
"0.48786375",
"0.48608088",
"0.4860535",
"0.4860535",
"0.4859022",
"0.48571905",
"0.48567882",
"0.485638",
"0.48521826",
"0.48458526",
"0.48449862",
"0.48372445",
"0.48301935",
"0.48218703",
"0.482174",
"0.4817616",
"0.4817537",
"0.48173696",
"0.48166502",
"0.48123765",
"0.48098144",
"0.4798504",
"0.4795799",
"0.47940585",
"0.47866896",
"0.4784486",
"0.47818598",
"0.47814956",
"0.4780881",
"0.47790462",
"0.47720656",
"0.47664645"
] |
0.68727684
|
0
|
Method that adds git repo (if it does not exist)
|
def add_repo_git(dir)
if not Dir.exist?("#{dir}/.git")
system_commands("git init #{dir}")
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add(path, param=File.split(path).last)\n unless self.has_repo?(param)\n begin\n list << Repo.new(path)\n rescue Rugged::RepositoryError\n logger.warn \"SKIPPING '#{path}' - not a git repository\"\n end\n end\n list\n end",
"def git_add_everything(host, git_repo_path)\n git_on(host, \"add #{git_repo_path}/*\", git_repo_path)\nend",
"def add_repository(name)\n system(\"#{gitlab_shell_user_home}/gitlab-shell/bin/gitlab-projects add-project #{name}.git\")\n end",
"def create_repo\n # update gitolite-admin/conf/gitolite.conf file ...\n # but only if there is NOT already an entry for this repo \n # ... to avoid duplicating the entry\n conf_entry = File.read(@@gitolite_conf_file_path).slice(@gitolite_conf_entry)\n if (conf_entry == nil)\n File.open(@@gitolite_conf_file_path, \"a\") { |f| f.write @gitolite_conf_entry}\n # push updates to gitolite-admin repo to create new project repo\n git_push @@gitolite_admin_path, \"Added repo #{@project_label} with users: #{@users}\"\n return true\n else\n LOGGER.error \"Existing gitolite config file entry found for project #{@project_label}, skipping repo creation\"\n return false\n end\n \n end",
"def add!()\n git \"add #{@path}\"\n end",
"def create_managed_repository\n OpenProject::Revisions::Git::GitoliteWrapper.update(:add_repository, self)\n rescue => e\n Rails.logger.error(\"Error while adding repository #{repository_identifier}: #{e.message}\")\n raise OpenProject::Scm::Exceptions::RepositoryBuildError.new(\n I18n.t('repositories.gitolite.cannot_add_repository')\n )\n end",
"def create_git_dir\n FileUtils.mkdir_p(@git_dir_path)\n FileUtils.cd(@git_dir_path)\n `git init &>/dev/null` # no effect if already initialized\n # Add github remote\n `git remote add origin git@github.com:#{@user}/#{@repo_name}.git &>/dev/null`\n end",
"def create_repo\n return Repo.open(self.path) if Dir.entries(self.path).include?('.git')\n g = Repo.init(self.path)\n Dir.chdir(self.path)\n File.open('.gitignore', 'w'){|f| f.write(\"*~\\n*.swp\") }\n g.add('.gitignore')\n g.commit(\"Initial Commit\")\n g\n end",
"def git_check\n # May throw InvalidRepositoryException\n # - because of invalid path\n # - or broken git repository\n @repo = GitLib::Repo.new(path)\n end",
"def add\n working_repo.add tree\n end",
"def add_git(git_remote, git_path, git_commit,\n high_priority: false,\n update: false,\n context_directory: nil)\n git_cache = @git_cache || Loader.default_git_cache\n path = git_cache.get(git_remote, path: git_path, commit: git_commit, update: update)\n @mutex.synchronize do\n raise \"Cannot add a git source after tool loading has started\" if @loading_started\n priority = high_priority ? (@max_priority += 1) : (@min_priority -= 1)\n source = SourceInfo.create_git_root(git_remote, git_path, git_commit, path, priority,\n context_directory: context_directory,\n data_dir_name: @data_dir_name,\n lib_dir_name: @lib_dir_name)\n @roots_by_priority[priority] = source\n @worklist << [source, [], priority]\n end\n self\n end",
"def add_git_facts\n # see if we're in a git repo. first, we need a directory that exists\n dir = @path.expand_path.ascend.find {|p| p.directory? }\n \n Dir.chdir(dir) do\n root_result = Cmds.new \"git rev-parse --show-toplevel\"\n \n unless root_result.ok?\n @result.in_git_repo = false\n @result.is_git_root = false\n return\n end\n \n @result.in_git_repo = true\n \n git = @result.git = Result.new\n git.root = Pathname.new root_result.out.chomp\n @result.is_git_root = @path == git.root\n \n user = git.user = Result.new\n \n ['name', 'email'].each {|key|\n user[key] = begin\n Cmds.chomp! \"git config user.#{ key }\"\n rescue\n end\n }\n \n git.origin = begin\n Cmds.chomp! \"git remote get-url origin\"\n rescue\n end\n \n match = GITHUB_SSH_URL_RE.match(git.origin) ||\n GITHUB_HTTPS_URL_RE.match(git.origin)\n \n git.is_github = !! match\n \n return unless match\n \n git.owner = match['owner']\n git.name = match['name']\n git.full_name = \"#{ git.owner }/#{ git.name }\"\n \n if true == @args['github_api']\n github = git.github = Result.new\n github.api_url = \"https://api.github.com/repos/#{ git.owner }/#{ git.name }\"\n \n response = Net::HTTP.get_response URI(github.api_url)\n \n if response.is_a? Net::HTTPSuccess\n # parse response body and add everything to github result\n parsed = JSON.parse response.body\n parsed.each {|k, v| github[k] = v}\n else\n # assume it's private if we failed to find it\n github.private = true\n end\n \n end\n end\n end",
"def create_repo\n Rugged::Repository.init_at(repo_path, :bare).tap do |repo|\n repo.remotes.create('origin', \"git@github.com:#{project.gh_path}\")\n repo.remotes.add_fetch_refspec('origin', GITHUB_PULLS_REFSPEC)\n end\n end",
"def add_master_repo\n cmd = ['master', url, 'master']\n cmd << '--shallow' if @shallow\n Repo::Add.parse(cmd).run\n end",
"def init_repo\n @logger.info \"repository url: #{@repository[:url]}\"\n\n if FileTest.exist?(@repository[:path])\n @logger.info \"repository path exists: #{@repository[:path]}\"\n @rgit = Git.open(@repository[:path], :log => @logger)\n @logger.info @rgit.fetch\n else\n @logger.info \"repository path doesn't exist: #{@repository[:path]}\"\n # Create LogDevice to log to websocket message\n @rgit = Git.clone(@repository[:url], @repository[:name],\n :path => @work_dir,\n :log => @logger)\n end\n end",
"def push_to_repo\n return if @remote_type == :none\n\n if @remote_type == :bitbucket\n puts 'Cannot automatically create BitBucket repository.'\n puts 'Please, open it manually at https://bitbucket.org/repo/create'\n `#{ENV['BROWSER']} https://bitbucket.org/repo/create`\n return\n end\n\n return unless %i[github].include?(@remote_type)\n\n gh_options = [\n @name,\n ]\n gh_options << '--team algolia' if @is_algolia\n\n if @is_private\n gh_options << '--private'\n else\n gh_options << '--public'\n end\n\n command = \"gh repo create #{gh_options.join(' ')}\"\n\n if command_success?(command)\n puts '✔ Creating GitHub repository'\n else\n puts '✘ Failed to create GitHub repository'\n exit 1\n end\n\n if command_success?('git push origin main')\n puts '✔ Pushed to repository'\n else\n puts '✘ Failed to push to repository'\n exit 1\n end\n end",
"def repo!(name='blah')\n path = File.join(PATH, name.to_s)\n FileUtils::mkdir_p(path)\n delete!(name)\n\n @repos ||= {}\n @current_repo = name.to_sym\n @repos[@current_repo] = SvnRepos.create(path)\n end",
"def require_git_repo(urls, commit)\n urls = filter_urls(rewrite_rules, [urls].flatten.compact)\n return if urls.empty?\n set_load_path!(\n checkout!(\n clone_one_of_repos!(urls), \n commit)\n )\n end",
"def init_git_repo(initial_commit: false)\n FileUtils::mkdir_p(@path)\n FileUtils.touch(@path.join('content'))\n\n new_repo = File.exists?(@path.join('.git')) != true\n @git = ::Git.init(@path.to_s, log: nil)\n @git.config('user.name', 'Philip Yu')\n @git.config('user.email', 'ht.yu@me.com')\n\n begin\n @git.tap(&:add).commit_all('initial commit') if new_repo && initial_commit\n rescue Git::GitExecuteError\n # Nothing to do (yet?)\n end\n @git.reset\n @path\n end",
"def repo_make(name)\n path = repo_path(name)\n path.mkpath\n Dir.chdir(path) do\n Pod::Executable.capture_command!('git', %w(init))\n Pod::Executable.capture_command!('git', %w(checkout -b main))\n repo_make_readme_change(name, 'Added')\n Pod::Executable.capture_command!('git', %w(add .))\n Pod::Executable.capture_command!('git', %w(commit -nm Initialized.))\n end\n path\n end",
"def create_repo(org, repo_name)\n if Commitchamp::Repo.find_by(name: repo_name, organization: org) == nil\n repo = @github.get_single_repo(org, repo_name)\n Commitchamp::Repo.find_or_create_by(name: repo['name']) do |r|\n r.organization = repo['organization']['login']\n r.full_name = repo['full_name']\n end\n end\n Commitchamp::Repo.find_by(name: repo_name, organization: org)\n end",
"def gem_git(name, options) # :nodoc:\n if gist = options.delete(:gist)\n options[:git] = \"https://gist.github.com/#{gist}.git\"\n end\n\n return unless repository = options.delete(:git)\n\n pin_gem_source name, :git, repository\n\n reference = gem_git_reference options\n\n submodules = options.delete :submodules\n\n @git_set.add_git_gem name, repository, reference, submodules\n\n true\n end",
"def gitrepo(repo, name, ref = 'master')\n mod name.split('/').join('-'),\n :git => \"https://#{repo}/#{name}.git\",\n :ref => ref\nend",
"def add_master_repo\n cmd = ['master', url, 'master', '--progress']\n Repo::Add.parse(cmd).run\n end",
"def sync_repo(org, repo)\n full_repo_name = \"#{org}/#{repo}\"\n full_repo_path = \"#{@git_dir}/#{org}/#{repo}\"\n\n # check whether repo exists on github.com\n is_github_repo = @github_client.repository?(full_repo_name)\n\n # check whether repo previously cloned\n is_cloned = Dir.exist?(full_repo_path)\n\n # check whether repo exists on ghe host\n is_ghe_repo = @ghe_client.repository?(full_repo_name)\n\n if is_github_repo\n if is_cloned && is_ghe_repo\n fetch_repo(full_repo_path)\n push_repo(full_repo_path)\n elsif is_cloned && !is_ghe_repo\n create_repo(org, repo)\n fetch_repo(full_repo_path)\n push_repo(full_repo_path)\n elsif !is_cloned && is_ghe_repo\n @logger.error 'Repo already exists on ghe'\n else\n clone_repo(full_repo_name, full_repo_path)\n create_repo(org, repo)\n push_repo(full_repo_path)\n end\n else\n @logger.error \"Repo doesn't exist on github.com\"\n end\n end",
"def install_git(module_path, module_name, repo, ref = nil)\n module_dir = File.join(module_path, module_name)\n\n Dir.chdir(module_path) do\n print_verbose \"cloning #{repo}\"\n system_cmd(\"git clone #{repo} #{module_name}\")\n Dir.chdir(module_dir) do\n system_cmd('git branch -r')\n system_cmd(\"git checkout #{ref}\") if ref\n end\n end\n end",
"def git_init\n require 'git'\n begin\n g = Git.open(@destination_root)\n logger.exists '.git'\n rescue ArgumentError\n g = Git.init(@destination_root)\n g.add(@destination_root)\n g.commit(\"beginning of #{@name} project\")\n logger.create '.git'\n end\n end",
"def git_init\n require 'git'\n begin\n g = Git.open(@destination_root)\n logger.exists '.git'\n rescue ArgumentError\n g = Git.init(@destination_root)\n g.add(@destination_root)\n g.commit(\"beginning of #{@name} project\")\n logger.create '.git'\n end\n end",
"def git_add\n `git add package.json npm-shrinkwrap.json`\n end",
"def prepare_git_repository\n # Allow one minute for slow repositories\n Grit::Git.git_timeout = 60.0\n\n Dir.chdir(@repository_path) do\n begin\n @repo = Grit::Repo.new('.')\n\n # Figure out the remote branch\n @remote = @repo.git.list_remotes.first\n @branch = @repo.head.name\n\n # Do a git-pull to make sure we have the newest changes from the repo\n if @remote\n puts \"Pulling any changes from the remote git repository...\"\n @repo.git.pull({}, @remote, @branch)\n end\n rescue Grit::InvalidGitRepositoryError\n puts \"ERROR: #{@repository_path} doesn't seem to be a git repository.\"\n end\n end\n end",
"def repo_init\n git :init\n end",
"def init_git\n unless options[:no_git]\n # grit can't init a repo yet. hopefully this happens some day\n inside(project) do\n `git init`\n repo = Grit::Repo.new(project)\n \n repo.add(\".\")\n repo.commit_all(\"initial commit\")\n end\n end\n end",
"def load_repository\n pwd = Pathname.new(ENV['PWD'].nil? ? Dir.getwd : ENV['PWD'])\n begin\n @repository = Grit::Repo.new(pwd + `cd #{pwd} && git rev-parse --git-dir 2>/dev/null`.chomp)\n rescue Grit::InvalidGitRepositoryError\n puts \"Not a valid git repo.\"\n exit!\n end\n end",
"def add_team_repo(id, org, repo)\n boolean_request :put, \"/teams/#{id}/repos/#{org}/#{repo}\"\n end",
"def git\n @git ||= Grit::Repo.new(path)\n end",
"def git\n @git ||= Grit::Repo.new(path)\n end",
"def create_repo(directory = nil)\n current_dir = File.expand_path('.')\n directory = current_dir if directory.nil?\n FileUtils.mkdir_p(directory) unless File.exist?(directory)\n Dir.chdir(directory)\n\n command = 'git init'\n success = command_success?(command)\n\n Dir.chdir(current_dir)\n success\n end",
"def git_repo\n @git_repo ||= GitRepo.new(\n git_config: project.repo_config,\n provider_credential: provider_credential\n )\n end",
"def init_repo\n return if check_deploy_dir\n FileUtils.mkdir_p @deploy_dir\n FileUtils.cd @deploy_dir do\n if Dir[@deploy_dir+'/*'].empty?\n\n # initialize the repository and add the remote.\n #\n `git init`\n `git remote add #{@remote} #{@repo}`\n\n # Attempt to pull from the remote.\n #\n if git_pull\n `git branch -m #{@branch}`\n\n # If no branch exists on remote, create one locally.\n else\n `echo \"initialize deploy repo\" > _`\n `git add .`\n `git commit -m \\\"initial commit\\\"`\n `git branch -m #{@branch}`\n `git rm _`\n `git add -u`\n `git commit -m 'cleanup'`\n end\n end\n end\n end",
"def validate_in_repo\n unless File.exist?('.git')\n raise NotInAGitRepository, \"We don't appear to be inside a Git repository!\"\n end\n end",
"def git_init_bare_repo_and_clone(host, git_repo_parent_path, git_repo_name, git_clone_path)\n origin_git_repo_path = git_init_bare_repo(host, git_repo_parent_path, git_repo_name)\n git_clone_repo(host, git_clone_path, origin_git_repo_path)\nend",
"def git\n # log \"Thread.current[:repo] nil? \" + Thread.current[:repo].nil?.to_s\n Thread.current[:repo] ||= clone(ARGV[0], ARGV[1])\n Thread.current[:repo]\n end",
"def create_remote_repo\n `git init --bare #{REMOTE_PATH}/#{@name}.git`\n\n # Connect local repository to remote and push local master branch to remote.\n Dir.chdir(\"#{LOCAL_PATH}/#{@name}\") do\n `git remote add #{UPSTREAM_NAME} #{REMOTE_PATH}/#{@name}.git && git push -u #{UPSTREAM_NAME} master`\n end\n end",
"def push_repo\n UI.puts \"\\nPushing the `#{@repo}' repo\\n\".yellow\n repo_git('push', 'origin', 'HEAD')\n end",
"def clone_and_pull_repo\n FileUtils.mkdir(project_path, :mode => 0744) unless File.directory?(project_path)\n\n clone_project_repo unless File.directory?(project_repo_path)\n fetch_and_pull_trunk\n end",
"def install_git(nr)\n install_git_packages\n checkout_path = clone_git_repo(nr)\n install_gem(nr, checkout_path)\n end",
"def update_repo\n git_push @project_git_work_path, \"Updated repo #{@project_label}\"\n return true\n end",
"def push(repo)\n before_push(repo)\n\n repo.cmd \"git remote add #{name} #{clone_url(repo)}\"\n repo.cmd \"git push --all #{name}\"\n after_push(repo)\n end",
"def updateGit(source)\n dir = File.basename(source.sub(/\\.git$/, ''))\n if File.exists?(dir)\n system 'cd '+dir+' && git pull' or exit 1\n else\n system 'git clone ' + source or exit 1\n end\nend",
"def updateGit(source)\n dir = File.basename(source.sub(/\\.git$/, ''))\n if File.exists?(dir)\n system 'cd '+dir+' && git pull' or exit 1\n else\n system 'git clone ' + source or exit 1\n end\nend",
"def setup_repo\n status(2) {\n setup_path\n if @type == 'full'\n Repository::Git.clone(@repo, @type)\n end\n Repository::Git.pull(@repo, @type)\n }\n end",
"def git_initialize\n g = Git.init\n g.add('.')\n g.commit('project created')\n end",
"def git_add_commit_push(host, branch, message, git_repo_path)\n git_add_everything(host, git_repo_path)\n git_commit_push(host, branch, message, git_repo_path)\nend",
"def clone_addon_repo(repoName, repoAddonURL, repoBlessedURL)\n self.log(INFO,repoName,\"Cloning : #{repoName} from #{repoAddonURL}...\")\n s = system(\"git clone --quiet #{repoAddonURL}\")\n if !s\n abort(\"[ERROR] Cloning of repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n Dir.chdir repoName\n self.log(INFO,repoName,\"Add blessed repository #{repoBlessedURL} for #{repoName} ...\")\n s = system(\"git remote add blessed #{repoBlessedURL}\")\n if !s\n abort(\"[ERROR] Adding blessed remote of repository #{repoName} failed !!!\\n\")\n end\n self.log(INFO,repoName,\"Done.\")\n end",
"def process_git_repo(url)\n\n repo = git_checkout_url(url)\n raise \"Unable to check out git repo.\" if repo.nil?\n\n process_directory(repo.project_dir)\n\n push_stats\n end",
"def add(file)\n @file = file\n FileUtils.cp_r(file.path,folder_path)\n unless system(\"cd #{repo_path};git add .\")\n raise GitCloud::GitException.new(\"Add\")\n end\n end",
"def repositorize_installed_gem\n # Do this only when gemsrc_clone_root is configured.\n # Because if gemsrc_clone_root is not configured, gem_dir/src is already a git repo,\n # and making gem_dir a git repo would cause \"adding embedded git repository: src\" warning\n return unless gemsrc_clone_root\n\n if File.directory? gem_dir\n puts \"gem-src: #{@spec.name} - repositorizing...\" if verbose?\n `cd #{gem_dir} && ! git rev-parse --is-inside-work-tree 2> /dev/null && git init && git checkout -qb gem-src_init && git add -A && git commit -m 'Initial commit by gem-src'`\n end\n\n # git remote add from the installed gem to the cloned repo so that we can easily transfer patches\n if File.directory?(clone_dir) && File.directory?(gem_dir)\n puts \"gem-src: #{@spec.name} - adding remotes...\" if verbose?\n `cd #{gem_dir} && git remote add src #{clone_dir}`\n origin = `cd #{clone_dir} && git remote get-url origin`.chomp\n `cd #{gem_dir} && git config remote.origin.url #{origin}` if origin\n end\n end",
"def git_clone(repo, config = {})\n config ||= {}\n destination = config[:destination] || File.basename(repo, '.git')\n\n destination = Pathname.new(destination) unless destination.is_a?(Pathname)\n FileUtils.mkdir_p destination.dirname\n\n if destination.directory?\n say_status :exist, destination.expand_path, :blue\n else\n say_status 'git clone',\n \"#{repo} to #{destination.expand_path}\",\n :green\n system \"git clone -q --config push.default=upstream --recursive #{repo} #{destination}\"\n end\n end",
"def github(name, ref = 'master')\n gitrepo \"github.com\", name, ref\nend",
"def git_wrapper (dpath = Dir.pwd)\n\n\tbegin\n\t\tRugged::Repository.new(dpath)\n\n\trescue Rugged::RepositoryError => err\n\n\t\tputs \"could not find repository at #{dpath}\"\n\t\texit 1\n\n\trescue Exception => err\n\n\t\tputs \"an error occurred while opening .git repository for #{dpath}\"\n\t\tputs err.message\n\t\texit 1\n\n\tend\n\nend",
"def update\n Repository.new(self).add_git_remote\n Hook.new(self).setup\n end",
"def clone(commit)\n repos_path = File.expand_path('repos')\n repo_path = File.join(repos_path, commit)\n @git = Git.open(repo_path) if FileTest.exist?(repo_path)\n @git = Git.clone(url, commit, path: repos_path) if @git.nil?\n end",
"def create_site_repo\n begin\n access_token = OAuth2::AccessToken.new(new_client, github_info.access_token)\n github_username = github_info.github_username\n\n repo_data = JSON.parse(access_token.get(\"/api/v2/json/repos/show/#{github_username}\"))\n repo_exists = repo_data[\"repositories\"].any? { |repo| repo[\"name\"] == remote_repo_name }\n p \"repo exists\" if repo_exists\n\n site_repo_created! if repo_exists\n rescue OAuth2::AccessDenied\n self.lost_github_access!\n end\n end",
"def add_remote(name, url, opts = {})\n url = url.repo.path if url.is_a?(Git::Base)\n self.lib.remote_add(name, url, opts)\n Git::Remote.new(self, name)\n end",
"def clone_git_repo(nr)\n checkout_path = ::File.join(Chef::Config[:file_cache_path], nr.gem_name)\n at_compile_time do\n git checkout_path do\n action :checkout\n repository nr.repository\n revision nr.revision\n end\n end\n checkout_path\n end",
"def goto_prj_dir\n git_repo_dir = git_dir + '/' + @options[:repo].split('/')[1]\n # chech that dir exist, otherwise clone it\n ck_or_clone_git\n begin\n # /tmp/gitarro, this is in case the dir already exists\n Dir.chdir git_repo_dir\n rescue Errno::ENOENT\n # this is in case we clone the repo\n Dir.chdir @options[:repo].split('/')[1]\n end\n end",
"def add_repo (repository_name)\n \"add-apt-repository -y #{repository_name} >/dev/null 2>/dev/null\"\n end",
"def repository!\n Repository.find_or_create_by!(url: repository_url) do |repo|\n repo.organization_id = org_id\n repo.name = repository_name\n end\n end",
"def git_init_bare_repo(host, git_repo_parent_path, git_repo_name)\n #Init\n git_repo_path = File.join(git_repo_parent_path, \"#{git_repo_name}.git\")\n\n #Initialize bare Git repository\n on(host, \"mkdir -p #{git_repo_path}\")\n on(host, \"git init --bare #{git_repo_path}\")\n\n return git_repo_path\nend",
"def goto_prj_dir(repo)\n git_repo_dir = @git_dir + \"/\" + repo.split('/')[1]\n # chech that dir exist, otherwise clone it\n if File.directory?(@git_dir) == false\n FileUtils.mkdir_p(@git_dir)\n Dir.chdir @git_dir\n puts `git clone git@github.com:#{repo}.git`\n end\n begin\n # /tmp/gitbot, this is in case the dir already exists\n Dir.chdir git_repo_dir\n rescue\n # this is in case we clone the repo\n Dir.chdir repo.split('/')[1]\n end\n end",
"def git_repo?\n !repository_root.to_s.empty?\n end",
"def git_init(ip, host)\n run \"git init\" unless dir_exists(\".git\")\n run \"git remote add webbynode git@#{ip}:#{host}\"\n run \"git add .\"\n run \"git commit -m \\\"Initial Webbynode Commit\\\"\"\n end",
"def clone_repository\n if File.directory?(base_path)\n repo = ::Git.open(base_path)\n repo.checkout(\"master\")\n repo.pull\n repo.fetch\n else\n ::Git.clone(url, base_path)\n end\n true\n end",
"def git_commit_and_push(cookbook_path, github_url)\n if File.exists?(File.join(cookbook_path, \".git\"))\n shell_out(\"git remote rm origin\", :cwd => cookbook_path)\n else\n shell_out!(\"git init\", :cwd => cookbook_path)\n end\n shell_out!(\"echo - $(date): Uploaded with knife github plugin. >> CHANGELOG.md \", :cwd => cookbook_path)\n shell_out!(\"git add .\", :cwd => cookbook_path)\n shell_out!(\"git commit -m 'creating initial cookbook structure from the knife-github plugin' \", :cwd => cookbook_path)\n shell_out!(\"git remote add origin #{github_url} \", :cwd => cookbook_path)\n shell_out!(\"git push -u origin master\", :cwd => cookbook_path)\n end",
"def gitAddCommit\n @gop.add(:all => true)\n\n begin\n @gop.commit(\"Automatic version bump\")\n rescue Git::GitExecuteError => giterror\n # continue\n end\n end",
"def update_repo\n puts \"starting to update_repo: '#{self.ident}'\"\n github = JSON.parse(Curl::Easy.perform(\"https://api.github.com/repos/\" + self.ident).body_str)\n \n if github[\"message\"]\n # Something has gone wrong\n # probably: repo does not exist\n # => 1) incorrect information provided when adding a repo\n # => 2) previously existing repo has had some changes (e.g. name, ownership)\n return false\n # do: better error handling here\n # what happens if a repo has been renamed / ownership transferred / deleted\n # => set flag 'needs_an_eye' to true\n # => then jump to the next repo\n # => might be done using 'markable' gem\n else\n %w{name description homepage}.each do |field|\n # set field or fall back to defaults\n self[field] = github[field] || \"\"\n end\n %w{watchers forks}.each do |field|\n # set field or fall back to defaults\n self[field] = github[field] || 0\n end\n\n self.github_url = github[\"html_url\"]\n self.owner = github[\"owner\"][\"login\"]\n self.last_updated = github[\"pushed_at\"]\n self.save\n end\n end",
"def git_init(repo_path)\n git_repo = Git.init repo_path\n git_repo.config('user.name', @@git_user_name)\n git_repo.config('user.email', @@git_user_email)\n return git_repo\n end",
"def call(path: Dir.pwd)\n git = git_open(path)\n return @error unless git\n\n remote = git.remotes.find { |r| r.name == @config['source_name'] }\n remote ||= git_remote_add(git)\n return @error unless remote\n\n return @error unless git_remote_update(remote)\n\n { success?: true }\n end",
"def create_repo(name)\n response = Faraday.post \"https://api.github.com/user/repos\", {name: \"#{name}\" }.to_json, {'Authorization'=>\"token #{self.access_token}\", 'Accept' => 'application/json'}\n end",
"def git_clone\n\n Rugged::Repository.clone_at git_url, root_path.to_s if git_url\n end",
"def exists?\n File.exists?(File.join(@repo_dir, '.git'))\n end",
"def git_repository?\n @root.join('.git').directory?\n end",
"def install_git\n\tsudo \"apt-get install git\" unless git_installed?\n end",
"def install_git\n\tsudo \"apt-get install git\" unless git_installed?\n end",
"def initialize_git\n inside(target_dir) do\n run(\"git init\", :capture => true)\n run(\"git add .\", :capture => true)\n end\n end",
"def create_repo(options)\n options = options.dup\n Repo.new(connection, post(\"/repos/create\", options)['repository'])\n end",
"def install_git\n begin\n run_context.resource_collection.include(package: 'git')\n rescue\n git_package = Chef::Resource::Package.new('git', run_context)\n git_package.name 'git'\n git_package.run_action :install\n end\n end",
"def add(repos)\n @repositories.add(repos)\n\n repositories\n end",
"def add_git_spec(name, version, repository, reference, submodules) # :nodoc:\n add_git_gem name, repository, reference, submodules\n\n source = Gem::Source::Git.new name, repository, reference\n source.root_dir = @root_dir\n\n spec = Gem::Specification.new do |s|\n s.name = name\n s.version = version\n end\n\n git_spec = Gem::Resolver::GitSpecification.new self, spec, source\n\n @specs[spec.name] = git_spec\n\n git_spec\n end",
"def commit_git_changes\n Dir.chdir(@repository_path) do\n status = @repo.status\n\n # Only add if we have untracked files\n if status.untracked.size > 0\n puts \"Adding new files to the repository...\"\n @repo.add(@repository_path + '/*')\n end\n\n commit_result = @repo.commit_all(\"Updating files\")\n\n # Attempt to push if anything was committed and we have a remote repo\n if commit_result !~ /working directory clean/\n if @remote\n puts \"Pushing repository changes...\"\n @repo.git.native(:push, {}, @remote, @branch)\n end\n else\n puts \"No changes committed.\"\n end\n end\n end",
"def find_repo_dir(here=Pathname.pwd)\n if (here + '.git').exist?\n return here\n else\n find_repo_dir(here.dirname) unless '/' == here.to_s\n end\nend",
"def create\n url = repo_params[:html_url]\n params = Repo.get_repo(url, current_user)\n if params == nil\n redirect_to :back, notice: 'Error with API access token.'\n return\n end\n if params == -1\n redirect_to :back, alert: 'Repo already exists' and return\n end\n\n params[:user_id] = current_user.id\n @repo = Repo.new(params)\n\n respond_to do |format|\n if @repo.save\n format.html { redirect_to @repo, notice: 'Repo was successfully created.' }\n format.json { render :show, status: :created, location: @repo }\n else\n format.html { render :new }\n format.json { render json: @repo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def giturl(project_name, repo_name) ; end",
"def install_git\n\tsudo \"brew install git\" unless git_installed?\n end",
"def install_git\n\tsudo \"brew install git\" unless git_installed?\n end",
"def git_clone_repo(host, git_clone_path, git_source)\n on(host, \"git clone #{git_source} #{git_clone_path}\")\nend",
"def create\n FileUtils.mkdir_p(@repos_path)\n @dirs_created << @repos_path\n ::Svn::Repos.create(@repos_path)\n self\n end",
"def install\n git_dir = GitDir.new(File.expand_path(\".\"))\n raise NotGitDirectoryError unless git_dir.is_git_directory?\n raise PostCommitAlreadyExistError if git_dir.has_post_commit_hook?\n\n git_dir.add_post_commit\n puts 'Gitstagram properly installed.'\n end",
"def test_add_existing_file\n @gitit.add('hello.txt', 'Hello, dsyph3r')\n @gitit.commit('modifying hello world')\n\n file = @gitit.get_file('hello.txt')\n\n assert_not_nil(file)\n\n assert_equal('Hello, dsyph3r', file['data'], 'File data is incorrect')\n end",
"def do_add_repo(repository,mirror_enabled,mirror_url,mirror_ca_cert)\n name = repository['name']\n url = repository['url']\n if !mirror_enabled\n cmd = \"helm repo add #{name} #{url} \"\n else\n if mirror_ca_cert == \"\"\n cmd = \"helm repo add #{name} #{mirror_url} \"\n else\n cmd = \"helm repo add --ca-file=/var/vcap/store/action/config/mirror_ca_cert.pem #{name} #{mirror_url} \"\n end\n end\n \"#{cmd};helm repo update\"\nend"
] |
[
"0.7786885",
"0.7279959",
"0.725854",
"0.71903586",
"0.7140012",
"0.70737445",
"0.7009269",
"0.6834908",
"0.67963755",
"0.67793787",
"0.6749535",
"0.6740471",
"0.6685378",
"0.66643465",
"0.6618561",
"0.6605729",
"0.66043293",
"0.65890884",
"0.65625286",
"0.65524465",
"0.65443647",
"0.6541822",
"0.65414894",
"0.6518298",
"0.65080714",
"0.65042245",
"0.648146",
"0.648146",
"0.6479101",
"0.64491355",
"0.64239967",
"0.64067984",
"0.63712746",
"0.6360716",
"0.63604623",
"0.63604623",
"0.63578284",
"0.6335356",
"0.62948895",
"0.62871987",
"0.62667996",
"0.6263442",
"0.62633955",
"0.62632185",
"0.62559915",
"0.6251471",
"0.6250871",
"0.62365395",
"0.61960536",
"0.61960536",
"0.6191916",
"0.61915314",
"0.6184522",
"0.6178041",
"0.6169866",
"0.61512387",
"0.6149722",
"0.6133056",
"0.61244667",
"0.6121112",
"0.61087644",
"0.6100821",
"0.6089881",
"0.60807884",
"0.60571057",
"0.6052561",
"0.6046112",
"0.60354424",
"0.6035064",
"0.60333586",
"0.6026908",
"0.6026038",
"0.6023844",
"0.6014582",
"0.600483",
"0.59932756",
"0.59885854",
"0.5968",
"0.5967786",
"0.5958296",
"0.5949627",
"0.59443665",
"0.59439087",
"0.59439087",
"0.59362036",
"0.5935196",
"0.5919601",
"0.5918707",
"0.5910888",
"0.59044653",
"0.58991927",
"0.5898924",
"0.5889065",
"0.58811367",
"0.58811367",
"0.58761275",
"0.5872927",
"0.58666605",
"0.5859432",
"0.58560663"
] |
0.83147377
|
0
|
Method to pull project request if user wants
|
def pull_execute(branch, dir)
vConfig(CONFIG['configWebsite'])
read_json(CONFIG['configWebsite'])
pull = @parse_json_config['deploy']['github']['config']['pull']
if pull == "yes"
system_commands("cd #{dir}; git pull origin #{branch}")
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def gh_pull_request(data, config)\n action = data['action'] || nil\n pr = data['pull_request'] || nil\n\n Cyclid.logger.debug \"action=#{action}\"\n return true unless action == 'opened' \\\n or action == 'reopened' \\\n or action == 'synchronize'\n\n # Get the list of files in the root of the repository in the\n # Pull Request branch\n html_url = URI(pr['base']['repo']['html_url'])\n pr_sha = pr['head']['sha']\n ref = pr['head']['ref']\n\n Cyclid.logger.debug \"sha=#{pr_sha} ref=#{ref}\"\n\n # Get some useful endpoints & interpolate the SHA for this PR\n url = pr['head']['repo']['statuses_url']\n statuses = url.gsub('{sha}', pr_sha)\n\n url = pr['head']['repo']['trees_url']\n trees = url.gsub('{/sha}', \"/#{pr_sha}\")\n\n # Get an OAuth token, if one is set for this repo\n Cyclid.logger.debug \"attempting to find auth token for #{html_url}\"\n auth_token = nil\n config['repository_tokens'].each do |entry|\n entry_url = URI(entry['url'])\n auth_token = entry['token'] if entry_url.host == html_url.host && \\\n entry_url.path == html_url.path\n end\n\n # XXX We probably don't want to be logging auth tokens in plain text\n Cyclid.logger.debug \"auth token=#{auth_token}\"\n\n # Set the PR to 'pending'\n GithubStatus.set_status(statuses, auth_token, 'pending', 'Preparing build')\n\n # Get the Pull Request\n begin\n trees_url = URI(trees)\n Cyclid.logger.debug \"Getting root for #{trees_url}\"\n\n request = Net::HTTP::Get.new(trees_url)\n request.add_field('Authorization', \"token #{auth_token}\") \\\n unless auth_token.nil?\n\n http = Net::HTTP.new(trees_url.hostname, trees_url.port)\n http.use_ssl = (trees_url.scheme == 'https')\n response = http.request(request)\n\n Cyclid.logger.debug response.inspect\n raise \"couldn't get repository root\" \\\n unless response.code == '200'\n\n root = Oj.load response.body\n rescue StandardError => ex\n Cyclid.logger.error \"failed to retrieve Pull Request root: #{ex}\"\n return_failure(500, 'could not retrieve Pull Request root')\n end\n\n # See if a .cyclid.yml or .cyclid.json file exists in the project\n # root\n job_url = nil\n job_type = nil\n root['tree'].each do |file|\n match = file['path'].match(/\\A\\.cyclid\\.(json|yml)\\z/)\n next unless match\n\n job_url = URI(file['url'])\n job_type = match[1]\n end\n\n Cyclid.logger.debug \"job_url=#{job_url}\"\n\n if job_url.nil?\n GithubStatus.set_status(statuses, auth_token, 'error', 'No Cyclid job file found')\n return_failure(400, 'not a Cyclid repository')\n end\n\n # Pull down the job file\n begin\n Cyclid.logger.info \"Retrieving PR job from #{job_url}\"\n\n request = Net::HTTP::Get.new(job_url)\n request.add_field('Authorization', \"token #{auth_token}\") \\\n unless auth_token.nil?\n\n http = Net::HTTP.new(job_url.hostname, job_url.port)\n http.use_ssl = (job_url.scheme == 'https')\n response = http.request(request)\n raise \"couldn't get Cyclid job\" unless response.code == '200'\n\n job_blob = Oj.load response.body\n case job_type\n when 'json'\n job_definition = Oj.load(Base64.decode64(job_blob['content']))\n when 'yml'\n job_definition = YAML.load(Base64.decode64(job_blob['content']))\n end\n\n # Insert this repository & branch into the sources\n #\n # XXX Could this cause collisions between the existing sources in\n # the job definition? Not entirely sure what the workflow will\n # look like.\n job_sources = job_definition['sources'] || []\n job_sources << { 'type' => 'git',\n 'url' => html_url.to_s,\n 'branch' => ref,\n 'token' => auth_token }\n job_definition['sources'] = job_sources\n\n Cyclid.logger.debug \"sources=#{job_definition['sources']}\"\n rescue StandardError => ex\n GithubStatus.set_status(statuses,\n auth_token,\n 'error',\n \"Couldn't retrieve Cyclid job file\")\n Cyclid.logger.error \"failed to retrieve Github Pull Request job: #{ex}\"\n raise\n end\n\n Cyclid.logger.debug \"job_definition=#{job_definition}\"\n\n begin\n callback = GithubCallback.new(statuses, auth_token)\n job_from_definition(job_definition, callback)\n rescue StandardError => ex\n GithubStatus.set_status(statuses, auth_token, 'failure', ex)\n return_failure(500, 'job failed')\n end\n end",
"def pull_request(_input)\n puts 'TODO: Implement Git.pull_request'\n # TODO: Validate input\n # input[:issue].to_s\n # input[:base_branch].to_s\n end",
"def execute\n if (!self.pull_request_id)\n current = GitHub::PullRequest.current\n self.pull_request_id = current.number if current\n end\n self.pull_request_id ||= cli.prompt(\"Pull Request ID: \")\n GitHub.connect do\n unless deployable? || @force\n CLI.say 'Pull request status checks have not passed. Cannot be marked deployable.'\n exit!\n end\n\n merge_result = merge\n add_deployable_label if config.deployable_label && merge_result\n end\n end",
"def is_branch_build\n self.pull_request_number == '-1'\n end",
"def propose_pull_request(github_account, params)\n params[:from] = \"#{github_account}:#{params[:from]}\"\n create_pull_request(params)\n end",
"def pull_request\n @pull_request ||= ApiFactory.new 'Repos::PullRequest'\n end",
"def pull_request(branch_name, m = nil)\n Retryable.do { api.pull_requests.list(api.user, api.repo) }.find { |pr| pr[\"head\"][\"ref\"] == branch_name }\n rescue Github::Error::ResourceNotFound\n if m\n m.user.msg \"sorry, but an error occurred while fetching your pull request\"\n end\n end",
"def query_pull_requests\n # This line is where we want to add :accept => 'application/vnd.github.shadow-cat-preview+json' for draft PRs\n pull_requests = github_query(@client) { @client.pull_requests(@repository, :state => 'open', :per_page => 50) }\n\n @pull_request_details = []\n\n pull_requests.each do |p|\n issue = github_query(@client) { @client.issue(@repository, p.number) }\n\n $logger.debug(\"Issue loaded: #{issue}\")\n\n notification_users = Set.new\n\n notification_users << issue.assignee.login if issue.assignee\n\n notification_users << p.user.login if p.user.login\n\n aging_pull_requests_notify = true\n aging_pull_requests_num_days = 7\n\n # TODO: p.head.repo can be null if the fork repo is deleted. Need to protect that here.\n if p.head.repo.nil?\n $logger.info(\"Skipping potential PR (#{p.number}): Forked repo is null (deleted?)\")\n else\n begin\n pb = PotentialBuild.new(@client, @token, p.head.repo.full_name, nil, p.head.sha, p.head.ref, p.head.user.login, nil, nil, p.number, p.base.repo.full_name, p.base.ref)\n configured_notifications = pb.configuration.notification_recipients\n unless configured_notifications.nil?\n $logger.debug(\"Merging notifications user: #{configured_notifications}\")\n notification_users.merge(configured_notifications)\n end\n\n aging_pull_requests_notify = pb.configuration.aging_pull_requests_notification\n aging_pull_requests_num_days = pb.configuration.aging_pull_requests_numdays\n\n if p.head.repo.full_name == p.base.repo.full_name\n $logger.info(\"Skipping pull-request originating from head repo: #{p.number}\")\n else\n $logger.info(\"Found an external PR to add to potential_builds: #{p.number}\")\n @potential_builds << pb\n end\n rescue DecentCIKnownError => e\n $logger.info(\"Skipping potential PR (#{p.number}): #{e}\")\n rescue => e\n $logger.info(\"Skipping potential PR (#{p.number}): #{e} #{e.backtrace}\")\n end\n end\n # TODO: Should this be here?\n @pull_request_details << {\n :id => p.number,\n :creator => p.user.login,\n :owner => (issue.assignee ? issue.assignee.login : nil),\n :last_updated => issue.updated_at,\n :repo => @repository,\n :notification_users => notification_users,\n :aging_pull_requests_notification => aging_pull_requests_notify,\n :aging_pull_requests_numdays => aging_pull_requests_num_days\n }\n end\n end",
"def execute\n if (!self.pull_request_id)\n current = GitHub::PullRequest.current\n self.pull_request_id = current.number if current\n end\n self.pull_request_id ||= cli.prompt(\"Pull Request ID: \")\n GitHub.connect do\n if config.deployable_label\n with_labelling do\n merge\n end\n else\n merge\n end\n end\n end",
"def update\n @pullRequest = PullRequest.find(params[:id])\n\t\t@git = Git.init()\n\t\tDir.chdir(@pullRequest.source_repo.path)\n\t\trequestor_path = \"#{@pullRequest.repository.path}\"\n\t\t@git.pull(requestor_path, \"master\") # fetch and a merge\n\t\t@pullRequest.status = \"ACCEPTED\"\n if @pullRequest.save\n\t\t\trespond_with(@pullRequest)\n\t\telse\n\t\t\trender json: {error: \"An error occurred while updating your pull request\"}\n end\n end",
"def create_pull_request\n unless uploads.empty?\n branch = patch_branch\n create_branch(branch)\n uploads.each do |key, upload|\n client.create_contents(\n repo,\n upload[\"filename\"],\n \"Create #{upload[\"filename\"]}\",\n session[\"file_#{key}\"],\n :branch => branch\n )\n session[\"file_#{key}\"] = nil\n end\n end\n pr = client.create_pull_request(repo, \"master\", branch, form_data[\"title\"], issue_body, :labels => labels)\n pr[\"number\"] if pr\n end",
"def open_pull_request\n outgoing_pull_requests.find(&:open?)\n end",
"def create_pull_request\n self.pull_request = GitHub::PullRequest.create config.github_repo, pull_request_attributes\n end",
"def ensure_pull_request(owner, repo, pullreq_id,\n comments = true, commits = true, history = true,\n state = nil, actor = nil, created_at = nil)\n pulls_reqs = db[:pull_requests]\n\n project = ensure_repo(owner, repo)\n\n if project.nil?\n warn \"Could not find repo #{owner}/#{repo} for retrieving pull request #{pullreq_id}\"\n return\n end\n\n retrieved = retrieve_pull_request(owner, repo, pullreq_id)\n\n if retrieved.nil?\n warn \"Could not retrieve pull_req #{owner}/#{repo} -> #{pullreq_id}\"\n return\n end\n\n base_repo = ensure_repo(retrieved['base']['repo']['owner']['login'],\n retrieved['base']['repo']['name'])\n\n base_commit = ensure_commit(retrieved['base']['repo']['name'],\n retrieved['base']['sha'],\n retrieved['base']['repo']['owner']['login'])\n\n if pr_is_intra_branch(retrieved)\n head_repo = base_repo\n head_commit = ensure_commit(retrieved['base']['repo']['name'],\n retrieved['head']['sha'],\n retrieved['base']['repo']['owner']['login'])\n debug pr_log_msg(retrieved) + ' is intra-branch'\n else\n head_repo = if pr_has_head_repo(retrieved)\n ensure_repo(retrieved['head']['repo']['owner']['login'],\n retrieved['head']['repo']['name'])\n end\n\n head_commit = if not head_repo.nil?\n ensure_commit(retrieved['head']['repo']['name'],\n retrieved['head']['sha'],\n retrieved['head']['repo']['owner']['login'])\n end\n end\n\n pull_req_user = ensure_user(retrieved['user']['login'], false, false)\n\n merged = if retrieved['merged_at'].nil? then false else true end\n closed = if retrieved['closed_at'].nil? then false else true end\n\n pull_req = pulls_reqs.first(:base_repo_id => project[:id],\n :pullreq_id => pullreq_id)\n if pull_req.nil?\n pulls_reqs.insert(\n :head_repo_id => if not head_repo.nil? then head_repo[:id] end,\n :base_repo_id => if not base_repo.nil? then base_repo[:id] end,\n :head_commit_id => if not head_commit.nil? then head_commit[:id] end,\n :base_commit_id => if not base_commit.nil? then base_commit[:id] end,\n :pullreq_id => pullreq_id,\n :intra_branch => pr_is_intra_branch(retrieved)\n )\n info 'Added ' + pr_log_msg(retrieved)\n else\n debug pr_log_msg(retrieved) + ' exists'\n end\n\n pull_req = pulls_reqs.first(:base_repo_id => project[:id],\n :pullreq_id => pullreq_id)\n\n # Add a fake (or not so fake) issue in the issues table to serve\n # as root for retrieving discussion comments for this pull request\n issues = db[:issues]\n issue = issues.first(:pull_request_id => pull_req[:id])\n\n if issue.nil?\n issues.insert(:repo_id => base_repo[:id],\n :assignee_id => nil,\n :reporter_id => nil,\n :issue_id => pullreq_id,\n :pull_request => true,\n :pull_request_id => pull_req[:id],\n :created_at => date(retrieved['created_at']))\n debug 'Added accompanying_issue for ' + pr_log_msg(retrieved)\n else\n debug 'Accompanying issue for ' + pr_log_msg(retrieved) + ' exists'\n end\n\n if history\n # Actions on pull requests\n opener = pull_req_user[:login]\n ensure_pull_request_history(pull_req[:id], date(retrieved['created_at']),\n 'opened', opener)\n\n merger = if retrieved['merged_by'].nil? then actor else retrieved['merged_by']['login'] end\n ensure_pull_request_history(pull_req[:id], date(retrieved['merged_at']),\n 'merged', merger) if (merged && state != 'merged')\n\n closer = if merged then merger else actor end\n ensure_pull_request_history(pull_req[:id], date(retrieved['closed_at']),\n 'closed', closer) if (closed && state != 'closed')\n ensure_pull_request_history(pull_req[:id], date(created_at), state, actor) unless state.nil?\n end\n ensure_pull_request_commits(owner, repo, pullreq_id, pull_req, retrieved) if commits\n ensure_pullreq_comments(owner, repo, pullreq_id, pull_req) if comments\n ensure_issue_comments(owner, repo, pullreq_id, pull_req[:id]) if comments\n\n pull_req\n end",
"def pull_request\n @pull_request ||= GitHub::PullRequest.new config.github_repo, pull_request_id\n end",
"def set_pull_request\n @pull_request = PullRequest.find(params[:id])\n end",
"def process_pull_request(pr, lang)\n\n # Statistics across pull request commits\n stats = pr_stats(pr)\n merged = !pr[:merged_at].nil?\n git_merged, merge_reason, merge_person = @close_reason[pr[:github_id]]\n\n # Count number of src/comment lines\n src = src_lines(pr[:id].to_f)\n\n if src == 0 then raise Exception.new(\"Bad src lines: 0, pr: #{pr[:github_id]}, id: #{pr[:id]}\") end\n\n months_back = 3\n commits_incl_prs = commits_last_x_months(pr, false, months_back)\n prev_pull_reqs = prev_pull_requests(pr,'opened')\n\n # Create line for a pull request\n {\n :pull_req_id => pr[:id],\n :project_name => \"#{pr[:login]}/#{pr[:project_name]}\",\n :lang => lang,\n :github_id => pr[:github_id],\n :created_at => Time.at(pr[:created_at]).to_i,\n :merged_at => merge_time(pr, merged, git_merged),\n :closed_at => Time.at(pr[:closed_at]).to_i,\n :lifetime_minutes => pr[:lifetime_minutes],\n :mergetime_minutes => merge_time_minutes(pr, merged, git_merged),\n :merged_using => merge_reason.to_s,\n :conflict => conflict?(pr),\n :forward_links => forward_links?(pr),\n :team_size => team_size_at_open(pr, months_back),\n :num_commits => num_commits(pr),\n :num_commits_open => num_commits_at_open(pr),\n :num_pr_comments => num_pr_comments(pr),\n :num_issue_comments => num_issue_comments(pr),\n :num_commit_comments => num_commit_comments(pr),\n :num_comments => num_pr_comments(pr) + num_issue_comments(pr) + num_commit_comments(pr),\n :num_participants => num_participants(pr),\n :files_added => stats[:files_added],\n :files_deleted => stats[:files_removed],\n :files_modified => stats[:files_modified],\n :files_changed => stats[:files_added] + stats[:files_modified] + stats[:files_removed],\n :src_files => stats[:src_files],\n :doc_files => stats[:doc_files],\n :other_files => stats[:other_files],\n :perc_external_contribs => commits_last_x_months(pr, true, months_back) / commits_incl_prs,\n :sloc => src,\n :src_churn => stats[:lines_added] + stats[:lines_deleted],\n :test_churn => stats[:test_lines_added] + stats[:test_lines_deleted],\n :commits_on_files_touched => commits_on_files_touched(pr, months_back),\n :commits_to_hottest_file => commits_to_hottest_file(pr, months_back),\n :test_lines_per_kloc => (test_lines(pr[:id]).to_f / src.to_f) * 1000,\n :test_cases_per_kloc => (num_test_cases(pr[:id]).to_f / src.to_f) * 1000,\n :asserts_per_kloc => (num_assertions(pr[:id]).to_f / src.to_f) * 1000,\n :watchers => watchers(pr),\n :requester => requester(pr),\n :closer => closer(pr),\n :merger => merge_person,\n :prev_pullreqs => prev_pull_reqs,\n :requester_succ_rate => if prev_pull_reqs > 0 then prev_pull_requests(pr, 'merged').to_f / prev_pull_reqs.to_f else 0 end,\n :followers => followers(pr),\n :intra_branch => if intra_branch?(pr) == 1 then true else false end,\n :main_team_member => main_team_member?(pr, months_back),\n :social_connection_tsay => social_connection_tsay?(pr),\n :hotness_vasilescu => hotness_vasilescu(pr, months_back),\n :team_size_vasilescu => team_size_vasilescu(pr, months_back),\n :description_complexity => description_complexity(pr),\n :workload => workload(pr),\n :prior_interaction_issue_events => prior_interaction_issue_events(pr, months_back),\n :prior_interaction_issue_comments => prior_interaction_issue_comments(pr, months_back),\n :prior_interaction_pr_events => prior_interaction_pr_events(pr, months_back),\n :prior_interaction_pr_comments => prior_interaction_pr_comments(pr, months_back),\n :prior_interaction_commits => prior_interaction_commits(pr, months_back),\n :prior_interaction_commit_comments => prior_interaction_commit_comments(pr, months_back),\n :first_response => first_response(pr),\n :ci_latency => ci_latency(pr),\n :ci_errors => ci_errors?(pr),\n :ci_test_failures => ci_test_failures?(pr),\n }\n end",
"def create_pull_request(token, branch, repo, body, assignee)\n payload = {:title => branch, :base => base_branch, :head => branch, :body => body}.to_json\n say \"Creating pull request for \"\n say \"#{branch} \", :green\n say \"against \"\n say \"#{base_branch} \", :green\n say \"in \"\n say repo, :green\n response = RestClient::Request.new(:url => \"https://api.github.com/repos/#{repo}/pulls\", :method => \"POST\", :payload => payload, :headers => {:accept => :json, :content_type => :json, 'Authorization' => \"token #{token}\"}).execute\n data = JSON.parse response.body\n\n assign_pull_request(token, branch, assignee, data) if assignee ## Unfortunately this needs to be done in a seperate request.\n\n url = data['html_url']\n url\n rescue RestClient::Exception => e\n process_error e\n throw e\n end",
"def add_coreq(addtl_pull_id, addtl_pull_repo, login, trigger_login, repo_to_pull_request, settings, trigger_updated_at, updated_at, base_pull_id, base_repo, comments)\n $stderr.puts \" Processing dependency on pull request #{addtl_pull_id} in repo '#{addtl_pull_repo}'\"\n # We can add the co-requisite if the author of the original pull request is trusted, or if the author of the trigger\n # statement is trusted and they authored the trigger statement after the co-requisite statement was made\n author_trusted = user_trusted?(login, addtl_pull_repo, settings)\n trigger_author_trusted = user_trusted?(trigger_login, addtl_pull_repo, settings)\n coreq_trigger_trusted = author_trusted || (trigger_author_trusted && (trigger_updated_at && trigger_updated_at >= updated_at))\n if coreq_trigger_trusted\n pull_request = get_pull_request(addtl_pull_id, addtl_pull_repo, 2)\n if pull_request\n # On co-requisite pull requests, we do not expect there to be trigger statements, as the\n # triggers on the parent pull request will trigger builds and tests with the co-requisites\n # therefore, we need to manage the mergeable state of the co-requisite pull requests here\n # while we're considering them for their parent\n if pull_request['mergeable']\n repo_to_pull_request[addtl_pull_repo] = pull_request\n set_mergeable(addtl_pull_id, addtl_pull_repo, pull_request['user']['login'])\n # Do nothing if the PR has been merged\n elsif !(pull_request['merged'])\n if set_not_mergeable(addtl_pull_id, addtl_pull_repo, pull_request['user']['login']) >= NOT_MERGEABLE\n comment = \"Linked pull request #{addtl_pull_id} in repo '#{addtl_pull_repo}' is not mergeable\"\n $stderr.puts \" #{comment}\"\n add_comment(base_pull_id, base_repo, comment) unless get_comment_with_value(base_pull_id, base_repo, comment, comments)\n end\n end\n else\n comment = \"Linked pull request #{addtl_pull_id} in repo '#{addtl_pull_repo}' not found\"\n $stderr.puts \" #{comment}\"\n add_comment(base_pull_id, base_repo, comment) unless get_comment_with_value(base_pull_id, base_repo, comment, comments)\n end\n else\n comment = \"User '#{login}' is not permitted to #{settings['name']} linked pull request #{addtl_pull_id} in '#{addtl_pull_repo}'. If the #{settings['name']} was requested by another user with permission to #{settings['name']} in '#{addtl_pull_repo}', the linked pull request must be in a comment before the #{settings['name']} comment (not including the pull request description) or be added by a user with permission to #{settings['name']} in '#{addtl_pull_repo}'.\"\n $stderr.puts \" #{comment}\"\n add_comment(base_pull_id, base_repo, comment) unless get_comment_with_value(base_pull_id, base_repo, comment, comments)\n end\n coreq_trigger_trusted\n end",
"def create\n\t\n\t##first check that user doesn't already have a pull request open for this repo line\n\t\t@idea = Idea.find(params[:idea_id])\n\t\t@toRepo = Repository.where(user_id: @idea.user_id).where(idea_id: params[:idea_id]).first\n\t\t@repo = Repository.where(user_id: current_user.id).where(idea_id: params[:idea_id]).first\n\t\t\n\n\t\t@pull_request = PullRequest.where(to_repo_id: @toRepo.id).where(repository_id: @repo.id).where(status: \"SUBMITTED\").first\n\t\tif( !@pull_request && current_user != @idea.user)\n\t @pullRequest = PullRequest.new()\n\n\t\t\t@pullRequest.repository_id = @repo.id\n\t\t\t@pullRequest.to_repo_id = @toRepo.id\n\t\t\t\n\t\t\t@pullRequest.message = params[:name]\n\t\t\t@pullRequest.save\n\t\t\t\n\t\t\tDir.chdir(@repo.path)\n\t\t\t@git = Git.init()\n\t\t\t@git.pull(@toRepo.path, \"master\") # fetch and a merge\n\t\tend\n\t\t\n\t\tif @pull_request\n\t\t\trespond_to do |format|\n\t\t\t\tformat.html # new.html.erb\n\t\t\t\tformat.json { render json: @pullRequest }\n\t\t\tend\n\t\telse\n\t\t\trender json: {error: \"Looks like something went wrong with creating a repo. Perhaps you already have one.\"}\n\t\tend\n end",
"def process_pull_request(req, updated_at, changed_after_eval, comments, settings, merge_pretest_success)\n id = req['number']\n branch = req['base']['ref']\n base_repo = req['base']['repo']['name']\n login = req['user']['login']\n repo_to_pull_request = {base_repo => req}\n pr_base_commit = base_repo_commit_for_pull_req(req)\n all_coreq_triggers_trusted = true\n\n $stderr.puts \"\\n****Processing #{settings['name'].upcase} in '#{branch}' branch for user '#{login}' on: #{GITHUB_BASE_URL}/#{Properties['github_user']}/#{base_repo}/pull/#{id}\"\n\n trigger_updated_at, trigger_login = get_trusted_trigger_time(req, comments, settings)\n\n evaluated_time = get_evaluated_time(comments, base_repo, settings)\n\n $stderr.puts \" Updated at: #{updated_at}\"\n $stderr.puts \" Changed after evaluated time: #{changed_after_eval}\"\n $stderr.puts \" Trigger updated at: #{trigger_updated_at}\"\n $stderr.puts \" Evaluated time: #{evaluated_time}\"\n\n # Gather any dependencies from trusted users and add them to the repo_to_pull_request mapping\n $repo_to_pull_regex.each do |repo, regex|\n next if repo == base_repo\n if req['body'] =~ regex\n addtl_pull_id = $2\n all_coreq_triggers_trusted &= add_coreq(addtl_pull_id, repo, login, trigger_login, repo_to_pull_request, settings, trigger_updated_at, Time.parse(req['updated_at']), id, base_repo, comments)\n end\n end\n\n comments.each do |comment|\n $repo_to_pull_regex.each do |repo, regex|\n next if repo == base_repo\n if comment['body'] =~ regex\n addtl_pull_id = $2\n all_coreq_triggers_trusted &= add_coreq(addtl_pull_id, repo, comment['user']['login'], trigger_login, repo_to_pull_request, settings, trigger_updated_at, Time.parse(comment['updated_at']), id, base_repo, comments)\n end\n end\n end\n\n updated_comment = nil\n status = nil\n build_url = nil\n # Find the bot comment for this pull request (or create one)\n process_or_create_comment(id, base_repo, settings, comments) do |comment_id, comment, comment_updated_at|\n submit_test_job = false\n resubmit_test_job = false\n fields = extract_bot_comment_fields(comment, settings)\n # Given the last comment made by the bot, we can determine the state in which evaluation\n # of this pull request ended previously, depending on which we will take different actions\n case fields[:state]\n when :evaluating\n # In this case, we have just made a placeholder comment as we have not seen this pull\n # request previously and are evaluating it for the first time. To move forward, we want\n # to ensure that all of the co-requisite pull requests have no updates more recent than\n # the most recent trigger we have seen.\n # TODO: we should *always* check this, above, not only in this state\n #\n # Two state transitions are possible out of this state:\n # - into the 'waiting for stable build' phase, as we cannot move to begin a test unless\n # the downstream jobs in Jenkins are ready to run them\n # - into the 'running tests' phase, if we have a trusted trigger that covers all the\n # commits in the main pull request and any co-requisites\n $stderr.puts \" Evaluating...\"\n\n if JenkinsAPI.project_stable?(branch, settings)\n # Make sure there is a trigger in place that is still later than the updated dates of each of the pull requests\n if trigger_updated_at\n repo_to_pull_request.each do |repo, pull_request|\n next if repo == base_repo\n if !user_trusted?(pull_request['user']['login'], repo, settings) && trigger_updated_at < Time.parse(pull_request['head']['repo']['updated_at'])\n create_or_update_comment(id, base_repo, ACTION_PREFIX, ACTION_NOT_TEAM, comments)\n break\n end\n end\n # The main pull request and all of the co-requisite pull requests haven't been\n # updated since the last trusted trigger, so we can begin testing\n update_evaluated_markers(repo_to_pull_request, trigger_updated_at, settings)\n submit_test_job = true\n else\n # no trusted trigger statement has been made, so we cannot build or test this pull\n create_or_update_comment(id, base_repo, ACTION_PREFIX, ACTION_NOT_TEAM, comments)\n end\n else\n updated_comment = compose_bot_comment(settings['test_prefix'], :content => waiting_for_stable_build_comment_segment(branch, settings), :state => :wait_stable_build)\n end\n\n when :wait_stable_build, :wait_queue_pos, :wait_in_queue\n # In this case, we are in one of two states:\n # 1) waiting for a downstream project in Jenkins to be stable, so we can begin tests\n # 2) determining build queue position\n #\n # Two state transitions are possible from state 1 and 2):\n # - loop back into state 1 (or 2) if the Jenkins project is unstable\n # - into the 'running tests' state if the Jenkins project is stable\n # If the main pull request or any of the co-requisites have been\n # updated since the last time we evaluated the main pull request, we need to re-queue the\n # build and test.\n #\n # TODO: currently, we have one invalid state that will make\n # it through this logic: the cases where we are not in the\n # build queue but have submitted tests. We need to\n # reconsider why this is tolerated\n $stderr.puts \" Waiting...\"\n # Only submit the tests if the project is stable\n if JenkinsAPI.project_stable?(branch, settings)\n submitted_tests = submitted_tests_for_branch(branch)\n if !submitted_tests[settings['name']]\n $stderr.puts \" Checking that evaluated times are still up to date\"\n if changed_after_eval\n resubmit_test_job = true\n else\n submit_test_job = true\n repo_to_pull_request.each do |repo, sub_pull_request|\n next if repo == base_repo\n $stderr.puts \" Checking evaluated time for sub pull request #{sub_pull_request['number']} for repo '#{repo}'\"\n sub_pull_comments = get_comments(sub_pull_request['number'], repo)\n sub_pull_request_updated_at, sub_pull_request_changed_after_eval = get_updated_at(sub_pull_request, sub_pull_comments, settings)\n\n $stderr.puts \" Updated at: #{sub_pull_request_updated_at}\"\n $stderr.puts \" Changed after evaluated time: #{sub_pull_request_changed_after_eval}\"\n if sub_pull_request_changed_after_eval\n resubmit_test_job = true\n break\n end\n end\n end\n else\n $stderr.puts \" Job is already queued\"\n end\n end\n when :running\n # In this state, we have triggered tests and made it through the build queue, so there\n # are running tests\n #\n # There are two state transitions possible from this state:\n # - loop back into this state if the tests are still running\n # - into the appropriate post-build state, of which I know of:\n # - SUCCESS\n # - ABORTED\n # - UNSTABLE\n # - NOT_FOUND\n\n # Capture the build_url from the regex match\n $stderr.puts \" Running: #{fields[:build_url]}consoleFull\"\n\n # If the build is finished, update with the results\n if JenkinsAPI.build_running?(fields[:build_url], branch, settings)\n submitted_tests = submitted_tests_for_branch(branch)\n submitted_tests[settings['name']] = true unless settings['allow_multiple']\n else\n result = JenkinsAPI.build_result(fields[:build_url], branch, settings)\n # Modify a copy so if we use fields below at some later time, we don't get a surprise\n new_fields = fields.dup\n new_fields[:state] = CONTENT_TO_STATE[result]\n updated_comment = compose_bot_comment(settings['test_prefix'], new_fields)\n status = result == 'SUCCESS' ? 'success' : 'failure'\n end\n when :failure\n # In this case, are in the post-test result state, and the tests have failed\n #\n # The two states that we can transition to from here are:\n # - loop back into this state if:\n # - flake enforcement is configured and\n # - there is no comment linking a valid flake issue to the last failed\n # job and\n # - the is no administrative trigger, overriding the check and\n # - the base branch of the pull request has not been updated from the\n # version used to run the tests previous ly\n # - into the testing state if either:\n # - flake enforcement is not configured, or\n # - a contributor has linked the failure to a flake issue, or\n # - an administrator has overriden the check, or\n # - new code has been pushed to the branch since the last time this bot\n # evaluated the pull request\n $stderr.puts \" Job failed: #{comment}\"\n\n flake_config = settings['flake_identification']\n if !flake_config\n # If no flake configuration exists, it's ok to re-submit the job whenever\n # a new trigger is added to the pull request\n $stderr.puts \" No flake identification configuration exists, resubmitting...\"\n resubmit_test_job = true\n else\n # If flake configuration does exist, we have to determine if we are OK to\n # re-submit or not\n $stderr.puts \" Determining if flakes have been identified for failed job: #{fields[:build_url]}\"\n\n admin_trigger_updated_at, _ = get_admin_trigger_time(req, comments, settings)\n admin_trigger_valid = admin_trigger_updated_at && admin_trigger_updated_at > updated_at\n if !admin_trigger_valid && !changed_after_eval\n # If there is nothing else that is going to re-trigger this job, we\n # look to find an explanatory comment. This is a costly process in\n # terms of API calls, so we only do it if we need to.\n explanatory_comment_valid = has_valid_flake_comment?(comments_after(comments, comment_updated_at), flake_config)\n else\n explanatory_comment_valid = false\n end\n\n flake_comment_prefix = flake_denied_prefix(base_repo, settings['name'])\n flake_comment_body = format_flake_comment(flake_comment_prefix, flake_config, settings['repo_to_admin_teams'][base_repo])\n\n # If we can find an explanatory comment with a valid flake issue in it,\n # or we find an admin override comment, or the pull request has had new\n # code added to it since the last evaluation, we know that we are good\n # to resubmit the pull request for testing\n if explanatory_comment_valid || admin_trigger_valid || changed_after_eval\n $stderr.puts format_flake_satisfaction_message(explanatory_comment_valid, admin_trigger_valid, changed_after_eval)\n resubmit_test_job = true\n delete_comment_with_prefix(id, base_repo, flake_comment_prefix, comments)\n else\n $stderr.puts \" Flake identification not satisfied\"\n if trigger_updated_at && trigger_updated_at > evaluated_time\n # If someone's tried to trigger a re-test, but we can't re-test right\n # now, we should leave a helpful message explaining why. If we have\n # previously warned the user about why we couldn't re-test, we should\n # only update the pull request with a new set of reasons if the trigger\n # is newer than our last comment\n previous_warning = get_comment_with_prefix(id, base_repo, flake_comment_prefix, comments)\n if !previous_warning || (previous_warning && trigger_updated_at > Time.parse(previous_warning['updated_at']))\n $stderr.puts \" New reminder comment is appropriate for this pull request\"\n recreate_comment_with_prefix(id, base_repo, flake_comment_prefix, flake_comment_body, comments)\n end\n end\n end\n end\n else\n # In this case, we're in one of three states:\n # 1) ACTION_NOT_MERGE: the pull request is not mergeable and needs a rebase\n # 2) ACTION_NOT_TEAM: the pull request has no trusted triggers\n # 3) the build has finished, with one of the following states:\n # - SUCCESS\n # - ABORTED\n # - UNSTABLE\n # - NOT_FOUND\n #\n # Regardless of the current state, since we have a trusted trigger, we want to\n # re-submit this pull request for testing.\n $stderr.puts \" Finished...\"\n $stderr.puts \" #{comment}\" if (fields[:prefix] == settings['test_prefix'] && fields[:build_url])\n resubmit_test_job = true\n end\n # Once we have considered the current state of the pull request, we need to determine\n # if we are going to submit this pull request for testing\n if resubmit_test_job\n # If analysis of the current state has determined that we should re-submit the job\n # for testing, we need to check that we meet all criteria for resubmission:\n # - is the project stable? [TODO: we seem to be checking this always, move up?]\n # - have there been any changes in the main pull request since the last evaluation?\n # - have there been any changes in the co-requisite pull requests since the last evaluation?\n #\n # TODO: this logic has bled out and should be moved into a function that is called\n # inside of each state case above, instead of being called this way. Ideally each\n # state case above should be able to either submit or not submit tests internally.\n submit_test_job = false\n\n $stderr.puts \" Checking whether we should resubmit\"\n if trigger_updated_at\n # We already trust the primary pull request. Just need to check whether the eval time is older than last update or last trusted trigger.\n if changed_after_eval || (evaluated_time < trigger_updated_at)\n if JenkinsAPI.project_stable?(branch, settings)\n submit_test_job = true\n else\n updated_comment = compose_bot_comment(settings['test_prefix'], :content => waiting_for_stable_build_comment_segment(branch, settings), :state => :wait_stable_build)\n end\n end\n\n # Check for any other reason to submit the test job. And make sure non of the sub pull requests have new untrusted changes.\n repo_to_pull_request.each do |repo, sub_pull_request|\n next if repo == base_repo\n\n $stderr.puts \" Checking evaluated time for sub pull request #{sub_pull_request['number']} for repo '#{repo}'\"\n sub_pull_comments = get_comments(sub_pull_request['number'], repo)\n sub_pull_request_updated_at, sub_pull_request_changed_after_eval = get_updated_at(sub_pull_request, sub_pull_comments, settings)\n\n $stderr.puts \" Updated at: #{sub_pull_request_updated_at}\"\n $stderr.puts \" Changed after evaluated time: #{sub_pull_request_changed_after_eval}\"\n\n # Make sure the trigger on the primary pull request is after the updated date of the sub pull request\n # or the user of the sub pull request is trusted\n valid_trigger_comment = trigger_updated_at > sub_pull_request_updated_at\n $stderr.puts \" Has valid trigger comment: #{valid_trigger_comment}\"\n if valid_trigger_comment || user_trusted?(sub_pull_request['user']['login'], repo, settings)\n if sub_pull_request_changed_after_eval\n if JenkinsAPI.project_stable?(branch, settings)\n submit_test_job = true\n else\n updated_comment = compose_bot_comment(settings['test_prefix'], :content => waiting_for_stable_build_comment_segment(branch, settings), :state => :wait_stable_build)\n end\n end\n else\n create_or_update_comment(id, base_repo, ACTION_PREFIX, ACTION_NOT_TEAM, comments)\n submit_test_job = false\n break\n end\n end\n else\n create_or_update_comment(id, base_repo, ACTION_PREFIX, ACTION_NOT_TEAM, comments)\n submit_test_job = false\n end\n if submit_test_job\n update_evaluated_markers(repo_to_pull_request, trigger_updated_at, settings)\n end\n end\n\n # To complete the transition into the next phase of the pull request evaluation,\n # we need to take the correct external actions if necessary and update the bot\n # comment to reflect the new state\n if submit_test_job\n delete_comment_with_prefix(id, base_repo, ACTION_PREFIX, comments)\n # Check for pretest_settings_key, so we might skip a round\n # of tests prior to merge\n extended_tests = get_extended_tests(req, comments, branch, settings)\n validate_and_submit_tests(repo_to_pull_request, base_repo, branch, id, comment_id, extended_tests, all_coreq_triggers_trusted, comments, settings, pr_base_commit['sha'])\n elsif updated_comment\n # If we have an `updated_comment`, we have determined which state we want to\n # transition into above literally and simply need to update the comment to\n # reflect that\n recreate_comment(id, comment_id, base_repo, updated_comment)\n repo_to_pull_request.each do |repo, pull_request|\n if status && build_url\n # One of the literal transitions we specify is the transition from running\n # tests to reporting the results, so if a result has been specified we\n # furthermore know that we are transitiong into the post-test state and can\n # update the GitHub pull request status\n commit = last_commit_for_pull_id(pull_request['number'], repo)\n update_status(settings['test_prefix'], commit['sha'], repo, status, build_url, (status == 'success') ? 'Passed' : 'Failed')\n end\n next if repo == base_repo\n # Update coreq comments with appropriate base commit ID\n coreq_fields = extract_bot_comment_fields(updated_comment, settings)\n cr_bot_comment = get_comment_with_prefix(pull_request['number'], repo, settings['test_prefix'])\n coreq_fields[:base_commit] = extract_bot_comment_fields(cr_bot_comment['body'], settings)[:base_commit]\n updated_comment = compose_bot_comment(settings['test_prefix'], coreq_fields)\n recreate_comment_with_prefix(pull_request['number'], repo, settings['test_prefix'], updated_comment)\n end\n elsif !repo_to_pull_request.empty?\n # If we are not running tests and have not specified a literal state to transition\n # into, we have one more transition to check: from post-build sucess to merge\n Properties['settings'].each_value do |s|\n # Check all_coreq_triggers_trusted in case trigger author can't merge all linked repos\n if s['pretest_settings_key'] && merge_pretest_success && all_coreq_triggers_trusted\n if Properties['settings'][s['pretest_settings_key']]['name'] == settings['name']\n if fields[:state] == :success\n build_url = fields[:build_url]\n trusted_trigger_time, trigger_login = get_trusted_trigger_time(req, comments, s)\n if trusted_trigger_time\n begin\n repo_to_pull_request.each do |repo, pull_request|\n test_merge_pull_request(pull_request['number'], repo, s)\n end\n repo_to_pull_request.each do |repo, pull_request|\n $stderr.puts \"\\n*******Merging pretested pull request: #{GITHUB_BASE_URL}/#{Properties['github_user']}/#{repo}/pull/#{pull_request['number']} \"\n merge_pull_request(pull_request['number'], repo, s, build_url)\n end\n rescue Exception => e\n $stderr.puts e.message\n $stderr.puts e.backtrace\n end\n end\n end\n break\n end\n end\n end\n end\n end\n\n end",
"def create_pullrequest options\n project = options.fetch(:project)\n params = {\n :base => options.fetch(:base),\n :head => options.fetch(:head)\n }\n\n if options[:issue]\n params[:issue] = options[:issue]\n else\n params[:title] = options[:title] if options[:title]\n params[:body] = options[:body] if options[:body]\n end\n\n res = post \"https://%s/repos/%s/%s/pulls\" %\n [api_host(project.host), project.owner, project.name], params\n\n res.error! unless res.success?\n res.data\n end",
"def process_pull_request(pr, lang)\n\n # Statistics across pull request commits\n stats = pr_stats(pr[:id])\n\n merged = ! pr[:merged_at].nil?\n git_merged = false\n merge_reason = :github\n\n if not merged\n git_merged, merge_reason = merged_with_git?(pr)\n end\n\n # Count number of src/comment lines\n src = src_lines(pr[:id].to_f)\n\n if src == 0 then raise Exception.new(\"Bad number of lines: #{0}\") end\n\n commits_last_3_month = commits_last_x_months(pr[:id], false, 3)[0][:num_commits]\n prev_pull_reqs = prev_pull_requests(pr[:id],'opened')[0][:num_pull_reqs]\n\n # Create line for a pull request\n {\n :pull_req_id => pr[:id],\n :project_name => \"#{pr[:login]}/#{pr[:project_name]}\",\n :lang => lang,\n :github_id => pr[:github_id],\n :created_at => Time.at(pr[:created_at]).to_i,\n :merged_at => merge_time(pr, merged, git_merged),\n :closed_at => Time.at(pr[:closed_at]).to_i,\n :lifetime_minutes => pr[:lifetime_minutes],\n :mergetime_minutes => merge_time_minutes(pr, merged, git_merged),\n :merged_using => merge_reason.to_s,\n :conflict => conflict?(pr[:login], pr[:project_name], pr[:github_id]),\n :forward_links => forward_links?(pr[:login], pr[:project_name], pr[:github_id]),\n :team_size => team_size_at_open(pr[:id], 3)[0][:teamsize],\n :num_commits => num_commits(pr[:id])[0][:commit_count],\n :num_commit_comments => num_comments(pr[:id])[0][:comment_count],\n :num_issue_comments => num_issue_comments(pr[:id])[0][:issue_comment_count],\n :num_comments => num_comments(pr[:id])[0][:comment_count] + num_issue_comments(pr[:id])[0][:issue_comment_count],\n :num_participants => num_participants(pr[:id])[0][:participants],\n :files_added => stats[:files_added],\n :files_deleted => stats[:files_removed],\n :files_modified => stats[:files_modified],\n :files_changed => stats[:files_added] + stats[:files_modified] + stats[:files_removed],\n :src_files => stats[:src_files],\n :doc_files => stats[:doc_files],\n :other_files => stats[:other_files],\n :perc_external_contribs => ((commits_last_3_month - commits_last_x_months(pr[:id], true, 3)[0][:num_commits]) * 100) / commits_last_3_month,\n :sloc => src,\n :src_churn => stats[:lines_added] + stats[:lines_deleted],\n :test_churn => stats[:test_lines_added] + stats[:test_lines_deleted],\n :commits_on_files_touched => commits_on_files_touched(pr[:id], Time.at(Time.at(pr[:created_at]).to_i - 3600 * 24 * 90)),\n :test_lines_per_kloc => (test_lines(pr[:id]).to_f / src.to_f) * 1000,\n :test_cases_per_kloc => (num_test_cases(pr[:id]).to_f / src.to_f) * 1000,\n :asserts_per_kloc => (num_assertions(pr[:id]).to_f / src.to_f) * 1000,\n :watchers => watchers(pr[:id])[0][:num_watchers],\n :requester => requester(pr[:id])[0][:login],\n :prev_pullreqs => prev_pull_reqs,\n :requester_succ_rate => if prev_pull_reqs > 0 then prev_pull_requests(pr[:id], 'merged')[0][:num_pull_reqs].to_f / prev_pull_reqs.to_f else 0 end,\n :followers => followers(pr[:id])[0][:num_followers],\n :intra_branch => if intra_branch?(pr[:id])[0][:intra_branch] == 1 then true else false end,\n :main_team_member => if main_team_member?(pr[:id])[0][:main_team_member] == 1 then true else false end\n }\n end",
"def pull_request(repo, number, options = {})\n get \"#{Repository.path repo}/pulls/#{number}\", options\n end",
"def pending_builds(project: nil)\n not_implemented(__method__)\n end",
"def execute\n current = GitHub::PullRequest.current\n\n if current\n cli.say \"Opening Pull Request #{current.number}\"\n cli.open current.pull_request.html_url\n end\n end",
"def ci_hook\n case request.headers['HTTP_X_GITHUB_EVENT']\n when 'pull_request'\n data = JSON.parse(request.raw_post)\n pull_request = data['pull_request']\n case data['action']\n when 'opened', 'synchronize'\n commits = JSON.parse(Net::HTTP.get_response(URI.parse(pull_request['commits_url'])).body)\n commits.each do |commit|\n APIHelper.authorized_post(\n \"https://api.github.com/repos/Charcoal-SE/SmokeDetector/statuses/#{commit['sha']}\",\n state: 'pending',\n description: 'An Approve review is required before pull requests can be merged.',\n context: 'metasmoke/ci'\n )\n end\n render plain: \"#{commits.length} commits set to pending.\"\n else\n render(plain: 'Not a newly-opened or updated PR; not interested.') && return\n end\n when 'pull_request_review'\n data = JSON.parse(request.raw_post)\n pull_request = data['pull_request']\n review = data['review']\n if data['action'] == 'submitted' && review['state'] == 'approved'\n commits = JSON.parse(Net::HTTP.get_response(URI.parse(pull_request['commits_url'])).body)\n commits.each do |commit|\n APIHelper.authorized_post(\n \"https://api.github.com/repos/Charcoal-SE/SmokeDetector/statuses/#{commit['sha']}\",\n state: 'success',\n description: 'PR approved :)',\n context: 'metasmoke/ci'\n )\n end\n\n render plain: \"#{commits.length} commits approved.\"\n else\n render(plain: 'Not a submitted Approve review; not interested.') && return\n end\n else\n render(plain: \"Pretty sure we don't subscribe to that event.\") && return\n end\n end",
"def get_pull_request(repo_full_name, pull_request_id)\n @client.pull_request(repo_full_name, pull_request_id)\n end",
"def create_pull_request(oauth_token, source_branch, base_branch, pr_title, pr_body, reviewers)\n client = Octokit::Client.new(access_token: oauth_token)\n pull_number = client.create_pull_request(full_repo_name, base_branch, source_branch, pr_title, pr_body)[:number]\n client.request_pull_request_review(full_repo_name, pull_number, reviewers: reviewers)\n end",
"def pull_request?\n !!issue.pull_request.html_url\n end",
"def pull_request?\n !!issue.pull_request.html_url\n end",
"def export_pull_request(pull_request_model)\n if pull_request_model.commits.empty?\n return log_with_url(\n severity: :warn,\n message: \"was skipped because the PR has no diff\",\n model: pull_request_model.pull_request,\n model_name: \"pull_request\",\n console: true\n )\n end\n\n pull_requests.push(\n PullRequestExporter.new(\n pull_request_model,\n repository_exporter: self,\n project: project\n )\n )\n end",
"def handle_repo_push_request\n return unless @repository\n\n branch_name = payload[\"ref\"].sub(%r{\\Arefs/heads/}, '')\n branch = @repository.branches.where(name: branch_name).first\n if branch.present? && branch.convergence? && @repository.run_ci?\n sha = payload[\"after\"]\n branch.kickoff_new_build_unless_currently_busy(sha)\n end\n end",
"def announce\n cli.say \"Preparing a pull request for #{config.github_repo}/#{git.current_branch} to #{config.github_repo}/#{destination_branch}.\"\n end",
"def testable_pull_request?(\n pr,\n admin_users,\n expected_body = 'test_it',\n options = {}\n )\n if ! pr['merged']\n if pr['mergeable']\n if pr['comments'] > 0\n comments = ::Github.new(options).issues.comments.all(\n pr['base']['user']['login'],\n pr['base']['repo']['name'],\n pr['number']\n )\n puts 'going through comments'\n comments.each do |comment|\n if admin_users.include?(comment['user']['login'])\n if comment['body'] == expected_body\n return true\n end\n end\n end\n else\n puts \"PR: #{pr['number']} from #{pr['base']['repo']['name']} has no issue commments.\\\n I will not test it. We only test things approved.\n \"\n end\n else\n puts \"PR: #{pr['number']} from #{pr['base']['repo']['name']} cannot be merged, will not test\"\n end\n else\n puts \"PR: #{pr['number']} from #{pr['base']['repo']['name']} was already merged, will not test\"\n end\n puts \"Did not find comment matching #{expected_body}\"\n return false\n end",
"def pull_requests_from_github\n @github.search_issues(\"is:pr state:open user:#{ORGANISATION}\").items\n end",
"def push\n ensure_git_and_cucumber_available\n ensure_repository\n\n puts \"Not implemented yet... pull request for push please!\"\n end",
"def current_requests(repo=source_repo)\n @github.pull_requests(repo)\n end",
"def develop_pr_check\n\n result = CheckResult.new(\"Develop PR Check Result\")\n\n ## PR should be sent from a branch that begins with `feature/`, `refactor/`, `fix/`, `issue/` or `version/`\n result.message << \"Head Branch check |\"\n is_from_feature = github.branch_for_head.start_with?(\"feature/\")\n is_from_refactor = github.branch_for_head.start_with?(\"refactor/\")\n is_from_fix = github.branch_for_head.start_with?(\"fix/\")\n is_from_issue = github.branch_for_head.start_with?(\"issue/\")\n is_from_version = github.branch_for_head.start_with?(\"version/\")\n if is_from_feature || is_from_refactor || is_from_fix || is_from_issue || is_from_version\n result.message << \":o:\\n\"\n else\n fail \"Please send the PR from a from a branch that begins with `feature/`, `refactor/`, `fix/`, `issue/` or `version/`.\"\n result.message << \":x:\\n\"\n result.errors += 1\n end\n\n ## PR should be sent to `develop` branch\n result.message << \"Base Branch check |\"\n is_to_develop = github.branch_for_base == \"develop\"\n if is_to_develop\n result.message << \":o:\\n\"\n else\n fail \"Please send the PR to `develop` branch.\"\n result.message << \":x:\\n\"\n result.errors += 1\n end\n\n ## If PR is sent from a branch that begins with `version/`, do a release modification check\n if is_from_version\n release_modification_check_into_result(result)\n end\n\n ## PR shouldn't contain any merge commits\n result.message << \"Merge Commits check |\"\n contains_merge_commits = git.commits.any? { |c| c.parents.length > 1 }\n unless contains_merge_commits\n result.message << \":o:\\n\"\n else\n fail \"Please don't contain any merge commits in the branch. Consider Rebase if required.\"\n result.message << \":x:\\n\"\n result.errors += 1\n end\n\n ## PR should have less than 1000 lines of modifications if possible.\n result.message << \"Modification Volumn check |\"\n is_fix_too_big = git.lines_of_code > 1_000\n unless is_fix_too_big\n result.message << \":o:\\n\"\n else\n warn \"Too many modifications. Please consider splitting the PR if possible.\"\n result.message << \":heavy_exclamation_mark:\\n\"\n result.warnings += 1\n end\n\n return result\n\nend",
"def pull_processor(payload)\n pull_request = payload[:pull_request]\n pull_request[:repository] = payload[:repository]\n new_pull = Hubstats::PullRequest.create_or_update(pull_request.with_indifferent_access)\n if payload[:github_action].include?('labeled')\n if payload[:github_action].include?('unlabeled') && payload[:label][:name].include?('qa-approved')\n Hubstats::QaSignoff.remove_signoff(payload[:repository][:id], payload[:pull_request][:id])\n elsif payload[:label][:name].include?('qa-approved')\n Hubstats::QaSignoff.first_or_create(payload[:repository][:id], payload[:pull_request][:id], payload[:sender][:id])\n end\n new_pull.update_label(payload)\n else\n repo_name = Hubstats::Repo.where(id: new_pull.repo_id).first.full_name\n labels = Hubstats::GithubAPI.get_labels_for_pull(repo_name, new_pull.number)\n new_pull.add_labels(labels)\n end\n new_pull.save!\n end",
"def update\n @project = Project.find(params[:id])\n #@old_repo = @project.repo_name\n\n respond_to do |format|\n if @project.update_attributes(params[:project])\n if @project.github_token? && @project.repo_name?\n create_hook\n end\n format.html { redirect_to projects_path, notice: 'Project was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @project.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_pull_request\n\t\t\tif deployment_id = params[:deployment_id]\n\t\t\t\t@deployment = Deployment.find_by_id(deployment_id)\n\t\t\t\t@pull_request = @deployment.pull_requests.find(params[:id])\n\t\t\t\t@deployable_application = @deployment.deployable_application\n\t\t\telse\n\t\t\t\t@pull_request = PullRequest.find(params[:id])\n\t\t\t\t@deployment = @pull_request.deployment\n\t\t\t\t@deployable_application = @pull_request.deployment.deployable_application\n\t\t\tend\n\t\tend",
"def merge_pull_request\n git.merge pull_request.branch\n end",
"def create_merge_request\n author_id, author_found = user_finder.author_id_for(pull_request)\n\n description = MarkdownText\n .format(pull_request.description, pull_request.author, author_found)\n\n attributes = {\n iid: pull_request.iid,\n title: pull_request.truncated_title,\n description: description,\n source_project_id: project.id,\n target_project_id: project.id,\n source_branch: pull_request.formatted_source_branch,\n target_branch: pull_request.target_branch,\n state: pull_request.state,\n milestone_id: milestone_finder.id_for(pull_request),\n author_id: author_id,\n assignee_id: user_finder.assignee_id_for(pull_request),\n created_at: pull_request.created_at,\n updated_at: pull_request.updated_at\n }\n\n create_merge_request_without_hooks(project, attributes, pull_request.iid)\n end",
"def single_pull_request(repo, pull_request_number)\n response = self.class.get(\"/repos/#{owner}/#{repo}/pulls/#{pull_request_number}\", options)\n\n return_value_for response\n end",
"def get_pull_request(project_id_or_key, repository_id_or_name, pull_request_number)\n get(\"projects/#{project_id_or_key}/git/repositories/#{repository_id_or_name}/pullRequests/#{pull_request_number}\")\n end",
"def get_pull_request(pr_id)\n r = BB.get(\"#{BB_API_BASE}/pull-requests/#{pr_id}\")\n raise \"Gotta Problem: #{r.reason_phrase}\" unless 'OK' == r.reason_phrase\n return JSON.parse(r.body)\nend",
"def checkPullRequest(id, fork=true)\n summary = getPullRequestSummary(id)\n puts \"checking pull request #{id}, branch #{summary.branch}\"\n files = getPullRequestFiles(id)\n `hg log -r #{summary.destination} 2>&1`\n if $? != 0\n puts \"Unknown revision #{summary.destination}, try: hg pull\"\n return\n end\n `hg log -r #{summary.source} 2>&1`\n if $? != 0\n puts \"Unknown revision #{summary.source}, try: hg pull \" +\n \"(it could also be a fork)\"\n return\n end\n ancestor=`hg log -r \"ancestor(#{summary.source},#{summary.destination})\" | head -1 | sed -e 's@.*:@@'`.chomp\n if ancestor != summary.destination\n puts \"Need to merge branch #{summary.branch} with #{summary.destination}\"\n end\n checkFiles(files, summary.source, fork)\n end",
"def create_pull_request_for_issue(repo, base, head, issue, options = {})\n pull = {\n :base => base,\n :head => head,\n :issue => issue\n }\n post \"#{Repository.path repo}/pulls\", options.merge(pull)\n end",
"def edit_requirement_file\n find_user\n if !@user.nil?\n status=@req.status\n assign_project\n if ((status!=\"Approved\" and params[:requirement][:status]==\"Approved\" and (@user.privilige==\"Admin\" or @user.privilige==\"Approve\" or @user.privilige==\"Read/Write/Approve\")) or (status!=\"Approved\" and params[:requirement][:status]!=\"Approved\" and (@user.privilige==\"Admin\" or @user.privilige==\"Read/Write\" or @user.privilige==\"Read/Write/Approve\" or @user.privilige==\"Approve\")) or (status==\"Approved\" and @user.privilige==\"Admin\")or (status==\"Approved\" and params[:requirement][:status]==\"Approved\" and !params[:requirement][:delivered].empty? and @user.privilige!=\"Read\"))\n if @req.update_attributes(params[:requirement])\n if (!params[:requirement][:status].nil?)\n\n if (status!=\"Approved\" and params[:requirement][:status]==\"Approved\")\n\n if !current_user.nil?\n first_name=@req.find_user_first_name(current_user.id)\n Requirement.notification_approved(current_user.id, @req.project_id, @req, first_name)\n else\n first_name=@req.find_member_first_name(@user.id)\n Requirement.notification_approved(@user.user_id, @req.project_id, @req, first_name)\n end\n elsif (status!=\"For Review\" and params[:requirement][:status]==\"For Review\")\n\n if !current_user.nil?\n first_name=@req.find_user_first_name(current_user.id)\n Requirement.notification_reviewed(current_user.id, @req.project_id, @req, first_name)\n else\n first_name=@req.find_member_first_name(@user.id)\n Requirement.notification_reviewed(@user.user_id, @req.project_id, @req, first_name)\n end\n elsif (status==\"Approved\" and params[:requirement][:status]!=\"Approved\")\n find_user\n if !current_user.nil?\n first_name=@req.find_user_first_name(current_user.id)\n Requirement.notification_no_approved(current_user.id, @req.project_id, @req, first_name)\n else\n first_name=@req.find_member_first_name(@user.id)\n Requirement.notification_no_approved(@user.user_id, @req.project_id, @req, first_name)\n end\n end\n end\n\n end\n @attr=Attribute.find_by_project_id(session[:project_id])\n if !session[:file_id].nil?\n @file=ProjectFile.find(session[:file_id])\n redirect_to show_file_reqs_url(@file.id)\n else\n redirect_to project_files_path\n end\n\n else\n\n\n flash[:notice]= t(:requirement_edit_message_with_out_permisson)\n redirect_to :back\n end\n else\n redirect_to sign_in_url\n end\n end",
"def fetch_project(input)\n input[:project] = { name: 'Fancy project', owner: { name: 'John Smith' } }\n Success(input)\n end",
"def create_pull_request(repository:, target:, from:, title:, description:)\n KIT.create_pull_request(repository, target, from, title, description)\n end",
"def process_pull_requests(merge_pretest_success)\n pull_requests = []\n mergeability_in_flux = false\n pull_request_statuses = Hash.new { |h,k| h[k] = Hash.new { |h2,k2| h2[k2] = {} } }\n $repo_to_pull_regex.keys.each do |repo|\n $stderr.puts \"\\nProcessing repo '#{repo}'\"\n pull_request_statuses[:closed_prs][repo] = \"#{GITHUB_BASE_URL}/#{Properties['github_user']}/#{repo}/pulls?q=is%3Apr+is%3Aclosed\"\n list_pull_requests(repo).each do |req|\n id = req['number']\n $stderr.puts \"Analyzing pull request: #{GITHUB_BASE_URL}/#{Properties['github_user']}/#{repo}/pull/#{id}\"\n\n branch = req['base']['ref']\n\n # We only want to consider pull requests into branches we care about\n if $branches.include?(branch) || $branches.include?('*')\n\n $stderr.puts \" Updated at: #{req['updated_at']}\"\n # We only want to consider pull requests that have been modified in\n # the last twelve hours, to stop us from doing extra work when we\n # don't need to. Also, just to ensure that we don't forget a pull\n # request forever on accident, there is a 10% chance we'll consider\n # a pull request even if it is inactive\n if Time.now - Time.parse(req['updated_at']) < (12*60*60) || (rand(20) < 1)\n login = req['user']['login']\n comments = nil\n # Skip if it's not mergeable\n mergeable = is_mergeable?(id, repo)\n $stderr.puts \" Mergeable: #{mergeable}\"\n if mergeable\n comments = get_comments(id, repo) if comments.nil?\n set_mergeable(id, repo, login, comments)\n else\n if set_not_mergeable(id, repo, login) == MERGEABLE\n mergeability_in_flux = true\n end\n next\n end\n\n comments = get_comments(id, repo) if comments.nil?\n\n # We only want to consider pull requests where the last trigger we found\n # is from a trusted user\n permission_denied = Array.new(Properties['settings'].length, false)\n # Has a merge or test been requested by a trusted user?\n Properties['settings'].values.each_with_index do |settings, i|\n updated_at, changed_after_eval = get_updated_at(req, comments, settings)\n trigger_regex = /\\[#{settings['name']}\\]/i\n if req['title'] =~ trigger_regex || req['body'] =~ trigger_regex\n if user_trusted?(login, repo, settings)\n pull_requests << [req, updated_at, changed_after_eval, comments, settings]\n permission_denied[i] = false\n next\n else\n $stderr.puts \" User '#{login}' not trusted\"\n permission_denied[i] = true\n end\n end\n\n comments = sort_comments(comments)\n comments.each do |comment|\n if comment['body'] =~ trigger_regex\n comment_login = comment['user']['login']\n if user_trusted?(comment_login, repo, settings)\n pull_requests << [req, updated_at, changed_after_eval, comments, settings]\n permission_denied[i] = false\n break\n else\n $stderr.puts \" User '#{comment_login}' not trusted\"\n permission_denied[i] = true\n end\n end\n end\n end\n if permission_denied.include? true\n create_or_update_comment(id, repo, ACTION_PREFIX, ACTION_NOT_TEAM, comments)\n end\n else\n $stderr.puts \" Skipping due to age and inactivity\"\n end\n else\n create_or_update_comment(id, repo, ACTION_PREFIX, ACTION_UNSUPPORTED_BRANCH)\n end\n end\n end\n\n if mergeability_in_flux\n $stderr.puts \"Waiting till next run to see if mergeability is in flux\"\n exit\n end\n\n # Consider the pull requests we have deemed valid in\n # order of the time they were last updated, oldest first\n sorted_pull_requests = pull_requests.sort_by do |req_info|\n req_info[1]\n end\n\n skipped_count = {}\n $branches.each do |branch|\n skipped_count[branch] = {}\n end\n\n # If we're only allowing sequential tests in this tag, we want to find\n # any pull request in the 'running tests' state and signal that there\n # is a test running.\n sorted_pull_requests.each do |req_info|\n req = req_info[0]\n comments = req_info[3]\n settings = req_info[4]\n branch = req['base']['ref']\n\n if !settings['allow_multiple']\n comments.each do |comment|\n begin\n fields = extract_bot_comment_fields(comment['body'], settings)\n if (comment['user']['login'] == Properties['bot_github_user']) && fields[:state] == :running\n submitted_tests = submitted_tests_for_branch(branch)\n submitted_tests[settings['name']] = true\n break\n end\n rescue Exception => e\n next\n end\n end\n end\n end\n\n sorted_pull_requests.each do |req_info|\n # Process the pull request\n req = req_info[0]\n updated_at = req_info[1]\n changed_after_eval = req_info[2]\n comments = req_info[3]\n settings = req_info[4]\n branch = req['base']['ref']\n repo = req['base']['repo']['name']\n\n process_pull_request(req, updated_at, changed_after_eval, comments, settings, merge_pretest_success)\n\n submitted_tests = submitted_tests_for_branch(branch)\n\n if !settings['allow_multiple'] && submitted_tests[settings['name']]\n # If we're only allowing sequential tests on this tag and there is a test running,\n # and we are waiting to test, we need to correctly determine the position in the\n # test queue that we are at and post it in a bot comment on the pull request\n comments = get_comments(req['number'], repo)\n\n bot_comment = get_comment_with_prefix(req['number'], repo, settings['test_prefix'], comments)\n if bot_comment\n fields = extract_bot_comment_fields(bot_comment['body'], settings)\n if (waiting_in_queue_state?(fields[:state]))\n skipped_count_branch = skipped_count[branch] ? skipped_count[branch] : skipped_count['*']\n skipped_count_branch[settings['name']] = 0 if skipped_count_branch[settings['name']].nil?\n skipped_count_branch[settings['name']] += 1\n queued_comment = compose_bot_comment(settings['test_prefix'], :state => :wait_in_queue, :content => waiting_in_queue_comment_segment(skipped_count_branch[settings['name']].to_s))\n pull_request_statuses[:enqueued][req['html_url']][:title] = req['title'].force_encoding(\"UTF-8\")\n pull_request_statuses[:enqueued][req['html_url']][:queue_pos] = skipped_count_branch[settings['name']]\n pull_request_statuses[:enqueued][req['html_url']][:repo] = repo\n create_or_update_comment(req['number'], repo, settings['test_prefix'], queued_comment , comments)\n $stderr.puts \" Pull ##{req['number']} in repo '#{repo}' is at build position ##{skipped_count_branch[settings['name']]}\"\n # Get ahead of the game and pretest requests\n if settings['pretest_settings_key'] && settings['pretest_comment'] && settings['pretest_queue_threshold'] && (skipped_count_branch[settings['name']] >= settings['pretest_queue_threshold'])\n trusted_trigger_time, _ = get_trusted_trigger_time(req, comments, Properties['settings'][settings['pretest_settings_key']])\n create_or_update_comment(req['number'], repo, settings['pretest_comment'].gsub('[', '\\[').gsub(']', '\\]'), settings['pretest_comment'], comments) unless trusted_trigger_time\n end\n elsif fields[:state] == :running\n pull_request_statuses[:running][req['html_url']][:title] = req['title'].force_encoding(\"UTF-8\")\n pull_request_statuses[:running][req['html_url']][:status] = \"merging\"\n pull_request_statuses[:running][req['html_url']][:repo] = repo\n end\n end\n end\n end\n # Commit merge queue records to disk\n IO.write(MERGE_QUEUE_RECORD, pull_request_statuses.to_json, {:mode => 'w'})\n end",
"def apply(pr, pull_request_hash)\n if !previously_applied?(pr) && matches?(pull_request_hash)\n add_reviewer(pr)\n end\n end",
"def contributor_pull_request(botpr_url)\n h = redis.hgetall(\"botpr:#{botpr_url}\")\n h.inject({}) { |acc, entry| acc[entry[0].to_sym] = entry[1]; acc }\n end",
"def current_requests_full(repo=source_repo)\n @github.pull_requests(repo).collect { |request|\n @github.pull_request(repo, request.number)\n }\n end",
"def extract_pull_request(an_array)\n pr_string_index = an_array.index{|s| s.include?(\"Merge pull request\")}\n pull_request = pr_string_index.nil? ? {} : parse_pull_request(an_array[pr_string_index])\n return pull_request\nend",
"def project?; @is_project || false; end",
"def pull_requests_for_commit(repo, commit_hash)\n query = \"#{commit_hash}+type:pr+repo:#{repo}\"\n say \"Searching github pull requests for #{commit_hash}\"\n github_api_request \"GET\", \"search/issues?q=#{query}\"\n end",
"def update(state = 'open')\n @current_requests = @github.pull_requests(source_repo, state)\n repos = @current_requests.collect do |request|\n repo = request.head.repository\n \"#{repo.owner}/#{repo.name}\" if repo\n end\n repos.uniq.compact.each do |rep|\n git_call \"fetch git@github.com:#{rep}.git +refs/heads/*:refs/pr/#{rep}/*\"\n end\n end",
"def request_join_project_button_enabled?(project)\n project.allow_request_membership?\n end",
"def add_pull_request_comment(project_id_or_key, repository_id_or_name, pull_request_number, params = {})\n get(\"projects/#{project_id_or_key}/git/repositories/#{repository_id_or_name}/pullRequests/#{pull_request_number}/comments\", params)\n end",
"def update\n @project = Project.find(params[:id])\n<<<<<<< HEAD:app/controllers/projects_controller.rb\n handle_disciplines_projects\n \n=======\n\n>>>>>>> 336471e6be257cf55c9afa2a65f928fde34e41fe:app/controllers/projects_controller.rb\n respond_to do |format|\n if @project.update_attributes(params[:project])\n flash[:notice] = 'Project was successfully updated.'\n format.html { redirect_to(@project) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @project.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def get_pull_requests(repo_full_name)\n @client.pull_requests(repo_full_name, state: 'open')\n end",
"def pull_requests repo\n name = full_name repo\n \n %w[open closed].reduce([]) do |memo, state|\n memo | octokit.pulls(name, state, :per_page=>100)\n end\n end",
"def pull_reqs(project, github_id = -1)\n q = <<-QUERY\n select u.login as login, p.name as project_name, pr.id, pr.pullreq_id as github_id,\n a.created_at as created_at, b.created_at as closed_at,\n\t\t\t (select created_at\n from pull_request_history prh1\n where prh1.pull_request_id = pr.id\n and prh1.action='merged' limit 1) as merged_at,\n timestampdiff(minute, a.created_at, b.created_at) as lifetime_minutes,\n\t\t\ttimestampdiff(minute, a.created_at, (select created_at\n from pull_request_history prh1\n where prh1.pull_request_id = pr.id and prh1.action='merged' limit 1)\n ) as mergetime_minutes\n from pull_requests pr, projects p, users u,\n pull_request_history a, pull_request_history b\n where p.id = pr.base_repo_id\n\t and a.pull_request_id = pr.id\n and a.pull_request_id = b.pull_request_id\n and a.action='opened' and b.action='closed'\n\t and a.created_at < b.created_at\n and p.owner_id = u.id\n and p.id = ?\n QUERY\n\n if github_id != -1\n q += \" and pr.pullreq_id = #{github_id} \"\n end\n q += 'group by pr.id order by pr.pullreq_id desc;'\n\n db.fetch(q, project[:id]).all\n end",
"def work_in_progress\n has_wip_label = danger_file.github.pr_labels.any? { |label| label.include? 'WIP' }\n has_wip_title = danger_file.github.pr_title.include? '[WIP]'\n\n danger_file.warn('PR is classed as Work in Progress') if has_wip_label || has_wip_title\n end",
"def index\n\t\t#should only grab pullRequests for current repository\n @pullRequests = PullRequest.where(to_repo_id: params[:repo_id]).where( status: \"SUBMITTED\")\n\n respond_with(@pullRequests)\n end",
"def perform\n @project.repo &:fetch\n end",
"def create_pull_request(repo, base, head, title, body = nil, options = {})\n pull = {\n :base => base,\n :head => head,\n :title => title,\n }\n pull[:body] = body unless body.nil?\n post \"#{Repository.path repo}/pulls\", options.merge(pull)\n end",
"def merge_pr_totarget(upstream, pr_branch)\n goto_prj_dir\n check_git_dir\n `git checkout #{upstream}`\n check_duplicata_pr_branch(\"#{pr_fix}#{pr_branch}\")\n `git remote update`\n `git fetch`\n `git pull origin #{upstream}`\n `git checkout -b #{pr_fix}#{pr_branch} origin/#{pr_branch}`\n return if $CHILD_STATUS.exitstatus.zero?\n\n # if it fails the PR contain a forked external repo\n repo_external.checkout_into\n end",
"def create(upstream=false)\n # prepare original_branch and local_branch\n original_branch, local_branch = prepare\n # don't create request with uncommitted changes in current branch\n if local.uncommitted_changes?\n puts 'You have uncommitted changes.'\n puts 'Please stash or commit before creating the request.'\n return\n end\n if local.new_commits?(upstream)\n # feature branch differs from local or upstream master\n if github.request_exists_for_branch?(upstream)\n puts 'A pull request already exists for this branch.'\n puts 'Please update the request directly using `git push`.'\n return\n end\n # push latest commits to the remote branch (create if necessary)\n git_call(\"push --set-upstream origin #{local_branch}\", debug_mode, true)\n create_pull_request(upstream)\n # return to the user's original branch\n # FIXME: keep track of original branch etc\n git_call(\"checkout #{original_branch}\")\n else\n puts 'Nothing to push to remote yet. Commit something first.'\n end\n end",
"def create_merge_request\n author_id, author_found = user_finder.author_id_for(pull_request)\n\n description = MarkdownText\n .format(pull_request.description, pull_request.author, author_found)\n\n # This work must be wrapped in a transaction as otherwise we can leave\n # behind incomplete data in the event of an error. This can then lead\n # to duplicate key errors when jobs are retried.\n MergeRequest.transaction do\n attributes = {\n iid: pull_request.iid,\n title: pull_request.truncated_title,\n description: description,\n source_project_id: project.id,\n target_project_id: project.id,\n source_branch: pull_request.formatted_source_branch,\n target_branch: pull_request.target_branch,\n state: pull_request.state,\n milestone_id: milestone_finder.id_for(pull_request),\n author_id: author_id,\n assignee_id: user_finder.assignee_id_for(pull_request),\n created_at: pull_request.created_at,\n updated_at: pull_request.updated_at\n }\n\n # When creating merge requests there are a lot of hooks that may\n # run, for many different reasons. Many of these hooks (e.g. the\n # ones used for rendering Markdown) are completely unnecessary and\n # may even lead to transaction timeouts.\n #\n # To ensure importing pull requests has a minimal impact and can\n # complete in a reasonable time we bypass all the hooks by inserting\n # the row and then retrieving it. We then only perform the\n # additional work that is strictly necessary.\n merge_request_id = GithubImport\n .insert_and_return_id(attributes, project.merge_requests)\n\n merge_request = project.merge_requests.find(merge_request_id)\n\n # These fields are set so we can create the correct merge request\n # diffs.\n merge_request.source_branch_sha = pull_request.source_branch_sha\n merge_request.target_branch_sha = pull_request.target_branch_sha\n\n merge_request.keep_around_commit\n merge_request.merge_request_diffs.create\n\n merge_request.id\n end\n rescue ActiveRecord::InvalidForeignKey\n # It's possible the project has been deleted since scheduling this\n # job. In this case we'll just skip creating the merge request.\n end",
"def db_update_pull_request(db, pr, org, repo)\n db[\n \"UPDATE items SET merged_at=? WHERE org=? AND repo=? AND item_number=?\",\n gh_to_db_timestamp(pr.merged_at), org, repo, pr.number.to_s].update\n end",
"def single_pull_request_response(fq_repo_name, pull_request_id)\n repository_url = \"https://api.github.com/repos/#{fq_repo_name}\"\n {\n \"id\" => pull_request_id,\n \"url\" => \"https://api.github.com/repos/#{fq_repo_name}/pulls/#{pull_request_id}\",\n \"number\" => pull_request_id,\n \"repository_url\" => repository_url,\n \"labels\" => [\n {\"name\" => \"bug\"},\n {\"name\" => \"wip\"}\n ],\n \"pull_request\" => {\n \"url\" => \"#{repository_url}/pulls/#{pull_request_id}\"\n }\n }.to_json\n end",
"def create_pull_request(project_id_or_key, repository_id_or_name, params = {})\n post(\"projects/#{project_id_or_key}/git/repositories/#{repository_id_or_name}/pullRequests\", params)\n end",
"def merge_pull_request(repo, number, commit_message='', options = {})\n put \"#{Repository.path repo}/pulls/#{number}/merge\", options.merge({:commit_message => commit_message})\n end",
"def create_pr\n ErrorEmittingExecutor.execute(\"hub pull-request -f -m '#{COMMIT_DESCRIPTION}'\")\nend",
"def project; end",
"def pull_reqs(project)\n q = <<-QUERY\n select u.login as login, p.name as project_name, pr.id, pr.pullreq_id as github_id,\n a.created_at as created_at, b.created_at as closed_at,\n\t\t\t (select created_at\n from pull_request_history prh1\n where prh1.pull_request_id = pr.id\n and prh1.action='merged' limit 1) as merged_at,\n timestampdiff(minute, a.created_at, b.created_at) as lifetime_minutes,\n\t\t\ttimestampdiff(minute, a.created_at, (select created_at\n from pull_request_history prh1\n where prh1.pull_request_id = pr.id and prh1.action='merged' limit 1)\n ) as mergetime_minutes\n from pull_requests pr, projects p, users u,\n pull_request_history a, pull_request_history b\n where p.id = pr.base_repo_id\n\t and a.pull_request_id = pr.id\n and a.pull_request_id = b.pull_request_id\n and a.action='opened' and b.action='closed'\n\t and a.created_at < b.created_at\n and p.owner_id = u.id\n and p.id = ?\n\t group by pr.id\n order by pr.pullreq_id desc;\n QUERY\n db.fetch(q, project[:id]).all\n end",
"def pull_request_attributes\n {\n title: title,\n destination_branch: destination_branch,\n source_branch: git.current_branch,\n pivotal_ids: pivotal_ids,\n jira_ids: jira_ids,\n editor: options[:editor]\n }\n end",
"def create\n @project = Project.new(params[:project])\n<<<<<<< HEAD:app/controllers/projects_controller.rb\n handle_disciplines_projects\n=======\n>>>>>>> 336471e6be257cf55c9afa2a65f928fde34e41fe:app/controllers/projects_controller.rb\n\n respond_to do |format|\n if @project.save\n flash[:notice] = 'Project was successfully created.'\n format.html { redirect_to(@project) }\n format.xml { render :xml => @project, :status => :created, :location => @project }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @project.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def ask_for_project(message)\n ask_for(message,projects)\n end",
"def set_mergeable(id, repo, login, comments=nil)\n merge_id=\"#{repo}_#{id}_#{login}\"\n count = MERGEABLE\n previous_merge_result=`grep #{merge_id} ~/test_pull_request_not_mergeable`.chomp\n if !previous_merge_result.empty? && previous_merge_result =~ /#{merge_id}=(\\d+)/\n count = $1.to_i\n end\n if count <= MERGEABLE\n # If our counter has saturated at 0, we want to remove any comments and labels about\n # rebasing as this pull request is mergeable\n `sed -i \"/#{merge_id}=/d\" ~/test_pull_request_not_mergeable`\n comments = get_comments(id, repo) if comments.nil?\n\n # In the majority of cases, we have all of the comments for a pull request, so we can\n # look to see if an ACTION_NOT_MERGE comment exists with zero additional API traffic.\n # If we find an ACTION_NOT_MERGE comment, we remove it, and furthermore we know we should\n # also delete the NEEDS_REBASE_LABEL. If we didn't remove the comment (because it didn't\n # exist, or because we failed through the API), we want to try to remove the label\n # anyway to ensure that the UX for PRs is good. Since we do *not* have the labels for\n # a PR, this is a costly operation, so we do not attempt to do it always, only when we\n # know for sure we need to, or once in a while randomly.\n if delete_comment_with_prefix(id, repo, ACTION_NOT_MERGE, comments) || (rand(5) < 1)\n remove_labels(id, repo, [NEEDS_REBASE_LABEL])\n end\n else\n # If our counter is not saturated, we pull it towards 0\n `sed -i \"/#{merge_id}=/d\" ~/test_pull_request_not_mergeable && echo \"#{merge_id}=#{(count-1).to_s}\" >> ~/test_pull_request_not_mergeable`\n end\n end",
"def update_pull_request(project_id_or_key, repository_id_or_name, pull_request_number, params = {})\n patch(\"projects/#{project_id_or_key}/git/repositories/#{repository_id_or_name}/pullRequests/#{pull_request_number}\", params)\n end",
"def release_pr_check\n\n result = CheckResult.new(\"Release PR Check Result\")\n\n ## PR should be sent from `develop` branch\n result.message << \"Head Branch check |\"\n is_from_develop = github.branch_for_head == \"develop\"\n if is_from_develop\n result.message += \":o:\\n\"\n else\n fail \"Please send the PR from `develop` branch.\"\n result.message += \":x:\\n\"\n result.errors += 1\n end\n\n ## PR should be sent to `master` branch\n result.message << \"Base Branch check |\"\n is_to_master = github.branch_for_base == \"master\"\n if is_to_master\n result.message += \":o:\\n\"\n else\n fail \"Please send the PR to `master` branch.\"\n result.message += \":x:\\n\"\n result.errors += 1\n end\n\n ## Release modification check\n release_modification_check_into_result(result)\n\n return result\n\nend",
"def create!(**options)\n options[:validate] = true if options[:validate].nil?\n return false if options[:validate] && !git_condition_valid?\n\n git.push(github_token_url, topic_branch)\n pr_number = github.create_pull_request(**generate_create_pr_options(**options))\n github.add_labels(pr_number, *options[:labels]) unless options[:labels].nil?\n unless options[:project_column_name].nil?\n github.add_to_project(pr_number, **generate_add_to_project_options(**options))\n end\n true\n end",
"def allow_request_membership?(user = User.current_user)\n user.present? &&\n project_administrators.any? &&\n !has_member?(user) &&\n MessageLog.recent_project_membership_requests(user.try(:person),self).empty?\n end",
"def perform_get_request(build_type_id, check_for_changes_only, branch: nil)\n if check_for_changes_only\n http_get \"httpAuth/action.html\", :checkForChangesBuildType => build_type_id\n else\n http_get \"httpAuth/action.html\", :add2Queue => build_type_id, :branchName => branch\n end\n end",
"def show_reminder\n repo = PluginsHelper.plugins_raw_url\n UI.notice \"Don't forget to create a Pull Request on #{repo}\\n\" \\\n ' to add your plugin to the plugins.json file once it is released!'\n end",
"def edit_requirement_tracker\n find_user\n if !@user.nil?\n\n status=@req.status\n\n if ((status!=\"Approved\" and params[:requirement][:status]==\"Approved\" and (@user.privilige==\"Admin\" or @user.privilige==\"Approve\" or @user.privilige==\"Read/Write/Approve\")) or (status!=\"Approved\" and params[:requirement][:status]!=\"Approved\" and (@user.privilige!=\"Read\")) or (status==\"Approved\" and @user.privilige==\"Admin\") or (status==\"Approved\" and params[:requirement][:status]==\"Approved\" and !params[:requirement][:delivered].empty? and @user.privilige!=\"Read\"))\n if @req.update_attributes(params[:requirement])\n if (!params[:requirement][:status].nil?)\n\n if (status!=\"Approved\" and params[:requirement][:status]==\"Approved\")\n\n if !current_user.nil?\n first_name=@project_req.find_user_first_name(current_user.id)\n Requirement.notification_approved(current_user.id, @req.project_id, @req, first_name)\n else\n first_name=@project_req.find_member_first_name(@user.id)\n Requirement.notification_approved(@user.user_id, @req.project_id, @req, first_name)\n end\n elsif (status!=\"For Review\" and params[:requirement][:status]==\"For Review\")\n\n if !current_user.nil?\n first_name=@req.find_user_first_name(current_user.id)\n Requirement.notification_reviewed(current_user.id, @req.project_id, @req, first_name)\n else\n first_name=@req.find_member_first_name(@user.id)\n Requirement.notification_reviewed(@user.user_id, @req.project_id, @req, first_name)\n end\n elsif (status==\"Approved\" and params[:requirement][:status]!=\"Approved\")\n\n if !current_user.nil?\n first_name=@req.find_user_first_name(current_user.id)\n Requirement.notification_no_approved(current_user.id, @req.project_id, @req, first_name)\n else\n first_name=@req.find_member_first_name(@user.id)\n Requirement.notification_no_approved(@user.user_id, @req.project_id, @req, first_name)\n end\n end\n end\n\n end\n @attr=Attribute.find_by_project_id(session[:project_id])\n if !session[:tracker_id].nil?\n @tracker=Tracker.find(session[:tracker_id])\n redirect_to show_tracker_req_url(@tracker.id)\n else\n redirect_to trackers_path\n end\n\n else\n\n\n flash[:notice]= t(:requirement_edit_message_with_out_permisson)\n redirect_to :back\n end\n else\n redirect_to sign_in_url\n end\n end",
"def ok_to_merge?(pull_request, data)\n pull_request.mergeable?\n # status_ok?(pull_request) &&\n # required_users_ok?(pull_request, data) &&\n # score_ok?(pull_request)\n end",
"def myPullRequests\n @pullRequests = PullRequest.where(user_id: current_user.id)\n respond_with(@pullRequests)\n end",
"def allow_request_membership?(user = User.current_user)\n user.present? &&\n project_administrators.any? &&\n !has_member?(user) &&\n ProjectMembershipMessageLog.recent_requests(user.try(:person),self).empty?\n end",
"def optional_pull\n if ARGV.include?(\"--pull\")\n puts %x(feature pull)\n end\nend",
"def allow_request_membership?(user = User.current_user)\n user.present? &&\n project_administrators.any? &&\n !has_member?(user) &&\n MessageLog.recent_project_membership_requests(user.try(:person),self).empty?\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 perform\n git.if_clean do\n check_out_branch\n merge_pull_request\n comment_about_merge\n end\n rescue => e\n case e\n when GitHub::PullRequest::NotFound\n cli.say \"Unable to find pull request #{pull_request_id}. Please retry with a valid ID.\"\n when Git::MergeFailed\n cli.say \"Merge failed. Please identify the source of this merge conflict resolve this conflict in your pull request's branch. NOTE: Merge conflicts resolved in the #{branch_type} branch are NOT used when deploying.\"\n when Git::CheckoutFailed\n cli.say \"Checkout of #{branch_to_merge_into} failed. Please contact Infrastructure to determine the cause.\"\n when GitHub::PullRequest::CommentFailed\n cli.say \"Unable to write comment. Please navigate to #{pull_request.url} and add the comment, '#{comment_body}'\"\n else\n cli.say \"An unknown error occurred: #{e.inspect}\"\n end\n raise\n end",
"def pull_request_hook\n unless request.request_parameters[:action] == 'opened'\n render(plain: 'Not a newly-opened PR. Uninterested.') && return\n end\n\n pull_request = params[:pull_request]\n\n SmokeDetector.send_message_to_charcoal(\"[PR##{pull_request[:number]}]\"\\\n \"(https://github.com/Charcoal-SE/SmokeDetector/pull/#{pull_request[:number]})\"\\\n \" (\\\"#{pull_request[:title]}\\\") opened by #{pull_request[:user][:login]}\")\n\n unless pull_request[:user][:login] == 'SmokeDetector'\n render(plain: 'Not from SmokeDetector. Uninterested.') && return\n end\n\n text = pull_request[:body]\n\n response_text = ''\n\n # Identify blacklist type and use appropriate search\n\n domains = text.scan(/<!-- METASMOKE-BLACKLIST-WEBSITE (.*?) -->/)\n\n domains.each do |domain|\n domain = domain[0]\n\n num_tps = Post.where('body REGEXP ?', domain).where(is_tp: true).count\n num_fps = Post.where('body REGEXP ?', domain).where(is_fp: true).count\n num_naa = Post.where('body REGEXP ?', domain).where(is_naa: true).count\n\n response_text += get_line domain, num_tps, num_fps, num_naa\n end\n\n keywords = text.scan(/<!-- METASMOKE-BLACKLIST-KEYWORD (.*?) -->/)\n\n keywords.each do |keyword|\n keyword = keyword[0]\n\n num_tps = Post.where('body REGEXP ?', keyword).where(is_tp: true).count\n num_fps = Post.where('body REGEXP ?', keyword).where(is_fp: true).count\n num_naa = Post.where('body REGEXP ?', keyword).where(is_naa: true).count\n\n response_text += get_line keyword, num_tps, num_fps, num_naa\n end\n\n usernames = text.scan(/<!-- METASMOKE-BLACKLIST-USERNAME (.*?) -->/)\n\n usernames.each do |username|\n username = username[0]\n\n num_tps = Post.where('username REGEXP ?', username).where(is_tp: true).count\n num_fps = Post.where('username REGEXP ?', username).where(is_fp: true).count\n num_naa = Post.where('username REGEXP ?', username).where(is_naa: true).count\n\n response_text += get_line username, num_tps, num_fps, num_naa\n end\n\n watches = text.scan(/<!-- METASMOKE-BLACKLIST-WATCH_KEYWORD (.*?) -->/)\n\n watches.each do |watch|\n watch = watch[0]\n\n num_tps = Post.where('body REGEXP ?', watch).where(is_tp: true).count\n num_fps = Post.where('body REGEXP ?', watch).where(is_fp: true).count\n num_naa = Post.where('body REGEXP ?', watch).where(is_naa: true).count\n\n response_text += get_line watch, num_tps, num_fps, num_naa\n end\n\n Octokit.add_comment 'Charcoal-SE/SmokeDetector', pull_request[:number], response_text\n\n render plain: response_text, status: 200\n end",
"def update_pull_requests(up_to=100)\n @pull_requests = client_for.pull_requests(@repo_data.full_name, :per_page => up_to)\n end",
"def resolve\n @issue = Issue.find(params[:id])\n @issue.resolved = 1\n @issue.authors = params[:solution][:author]\n @issue.github = params[:solution][:github]\n @issue.submitter_id = current_user.id\n\n #update latest repo for the project\n @project = Project.find(@issue.project_id)\n @project.github_site = params[:solution][:github]\n\n #TODO: @project.save and \n #@project.update_attributes(params[:project])\n if @project.save && @issue.save \n flash[:notice] = \"Your Solution was Submitted\"\n redirect_to project_issue_path(@project.slug,@issue.id)\n else\n flash[:error] = \"Error in Saving. Please retry.\"\n redirect_to project_issue_path(@project.slug,@issue.id)\n end\n UserMailer.resolution_submitted(@issue, current_user).deliver unless not current_user.email_notification.issues_approval\n end"
] |
[
"0.7001284",
"0.68103707",
"0.6736298",
"0.66228366",
"0.6607244",
"0.6573737",
"0.6538799",
"0.653458",
"0.64818114",
"0.640499",
"0.63741964",
"0.632654",
"0.6323931",
"0.62986076",
"0.6297217",
"0.6293655",
"0.62855625",
"0.6278223",
"0.6267136",
"0.6261666",
"0.6254019",
"0.6232665",
"0.62294245",
"0.6226597",
"0.62013966",
"0.6175982",
"0.61611456",
"0.61417437",
"0.61140466",
"0.6073952",
"0.6073952",
"0.60596067",
"0.60378337",
"0.602942",
"0.6020562",
"0.59951454",
"0.5981005",
"0.5980714",
"0.5927892",
"0.5908237",
"0.5901723",
"0.58943915",
"0.58544475",
"0.58292246",
"0.58199495",
"0.5817037",
"0.58145964",
"0.5803765",
"0.57921886",
"0.57864726",
"0.578147",
"0.5768623",
"0.5768243",
"0.5767755",
"0.5761579",
"0.5755313",
"0.57543045",
"0.5746682",
"0.57455343",
"0.5742763",
"0.5714901",
"0.5714412",
"0.57125944",
"0.5710171",
"0.5705652",
"0.56984615",
"0.56960696",
"0.56811845",
"0.5680722",
"0.5670219",
"0.5661487",
"0.5659147",
"0.5654454",
"0.56282204",
"0.5626329",
"0.562426",
"0.5619367",
"0.5599598",
"0.5596645",
"0.5593351",
"0.5592901",
"0.55778104",
"0.55684066",
"0.5568327",
"0.556489",
"0.55595064",
"0.5558072",
"0.5555767",
"0.555012",
"0.5546587",
"0.5545256",
"0.5538017",
"0.5529189",
"0.5527337",
"0.55160886",
"0.5513151",
"0.5512626",
"0.550682",
"0.5501268",
"0.54942334",
"0.54942"
] |
0.0
|
-1
|
Method to check if a given branch exists and enter or create the same.
|
def git_checkout(setBranch, dir)
getBranch = `cd #{dir}; git branch --list | sed -n "/#{setBranch}/p" | cut -d'*' -f2 | awk '{ gsub (" ", "", $0); print}'`
if getBranch.nil? || getBranch.empty?
system_commands("cd #{dir}; git checkout -b #{setBranch}")
else
system_commands("cd #{dir}; git checkout #{getBranch}")
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create_branch\n check_current_repo\n exists = `git branch --list #{branch}`.squish == branch\n if exists\n `git checkout #{branch}`\n else\n `git checkout master` unless current_branch == 'master'\n `git checkout -b #{branch}`\n end\nend",
"def branch_exists?(branch = branch_name)\n git.capturing.rev_parse({:verify => true, :quiet => true}, \"refs/heads/#{branch}\")\n true\n rescue MiniGit::GitError\n false\n end",
"def branch_exists?(branch)\n return unless self.working_directory\n\n result = Dir.chdir(self.working_directory) do\n FastlaneCore::CommandExecutor.execute(command: \"git --no-pager branch --list origin/#{branch.shellescape} --no-color -r\",\n print_all: FastlaneCore::Globals.verbose?,\n print_command: FastlaneCore::Globals.verbose?)\n end\n return !result.empty?\n end",
"def branch_present?(branch, **options)\n GitHub::Errors.with_error_handling do\n @client.branches(full_name, options).map(&:name).include? branch\n end\n rescue GitHub::Error\n false\n end",
"def branch_exists?(location, branch_name)\n return false unless [:remote, :local].include? location\n prefix = location == :remote ? 'remotes/origin/' : ''\n all_branches.include?(prefix + branch_name)\n end",
"def create_branch(name)\n begin\n res = satelliterepo.create_branch(name)\n rescue\n return nil\n end\n pushtobare name\n res\n end",
"def branch_exists?(name)\n rugged.branches.exists?(name)\n\n # If the branch name is invalid (e.g. \".foo\") Rugged will raise an error.\n # Whatever code calls this method shouldn't have to deal with that so\n # instead we just return `false` (which is true since a branch doesn't\n # exist when it has an invalid name).\n rescue Rugged::ReferenceError\n false\n end",
"def branch_exists?(branch_name, options = {})\n options = {\n :remote => true,\n :local => true,\n :repo => nil\n }.merge(options)\n remote = options[:remote]\n local = options[:local]\n repo = options[:repo] || default_repository\n unless local || remote\n raise ::ArgumentError, 'Either remote or local must be true'\n end\n both = local && remote\n repo.branches(:all => remote).any? do |branch|\n branch.name == branch_name && (both || remote == branch.remote?)\n end\n end",
"def create_releases_for_branch?(branch)\n release_branch == branch\n end",
"def create_branch new_branch_name\n repo.create_branch new_branch_name\n end",
"def create_branch\n ErrorEmittingExecutor.execute(\"git checkout -B #{BRANCH_NAME}\")\n\n # Ensure local branch matches any existing upstream branch; will reset to HEAD by default\n ErrorEmittingExecutor.execute('git reset --hard', exit_on_error: true)\nend",
"def create_branch(name)\n return unless /[a-z0-9\\-_]/.match name\n begin\n res = satelliterepo.create_branch(name)\n rescue\n return nil\n end\n pushtobare name\n res\n end",
"def branch(name)\n gitrepo.create_branch(name)\n end",
"def check_duplicata_pr_branch(pr)\n puts `git branch --list #{pr}`\n `git branch -D #{pr} 2>/dev/null` if $CHILD_STATUS.exitstatus.zero?\n end",
"def create_branch(_base_branch, _new_branch)\n puts 'TODO: Implement Git.create_branch'\n end",
"def in_branch(name, &block)\n previous_branch = current_branch\n\n if name != previous_branch\n git \"branch\", name unless branches.include?(name)\n git \"checkout\", name\n end\n \n yield\n rescue StandardError\n STDERR.puts $!\n raise\n ensure\n unless current_branch == previous_branch\n git \"reset\", \"--hard\"\n git \"checkout\", previous_branch\n end\n end",
"def check_out_branch\n git.check_out branch_to_merge_into\n rescue Git::NoBranchOfType\n cli.say \"No #{branch_type} branch available. Creating one now.\"\n git.check_out DatedBranchCreator.perform(branch_type).branch_name\n end",
"def git_branch_create(new_branch_name)\n repo.create_branch(new_branch_name)\n end",
"def create_branch(branch)\n client.create_ref repo, \"heads/#{branch}\", base_sha\n end",
"def check_branch\n same_branch = `git branch -a` =~ /\\* #{@branch}/\n\n if current_remote = `git remote -v`.match(/\\s\\S+/)\n same_remote = current_remote[0].match(/#{@repo}/)\n end\n\n if same_remote && same_branch\n puts \"Deploy to #{@branch} canceled:\".red\n puts \"You cannot deploy to the same branch you are working in. This will overwrite the source for your site.\\n\"\n puts \"First, back up your site's source to a branch:\"\n puts \"\\n git checkout -b source\".yellow\n puts \" git push origin source\".yellow\n puts \"\\nWith that, you'll work in the #{\"source\".bold} branch and deploy to the #{@branch.bold} branch.\"\n abort\n end\n end",
"def create_branch(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false)\n Qo::Branches::Branch.create(\n name: name,\n precondition: precondition,\n extractor: extractor,\n destructure: destructure,\n default: default\n )\n end",
"def create( branch, newattrs={} )\n\t\tnewattrs = normalize_attributes( newattrs ) if newattrs.is_a?( Hash )\n\t\tself.conn.add( branch.to_s, newattrs )\n\n\t\treturn true\n\tend",
"def patch_branch\n num = 1\n branch_name = form_data[\"title\"].parameterize\n return branch_name unless branch_exists?(branch_name)\n branch = \"#{branch_name}-#{num}\"\n while branch_exists?(branch) do\n num = num + 1\n branch = \"#{branch_name}-#{num}\"\n end\n branch\n end",
"def add_branch?(new_branch, opts = {})\n add_branch = true\n if get_branches.include?(new_branch)\n if opts[:delete_existing_branch]\n delete_local_and_remote_branch(new_branch)\n else\n add_branch = false\n end\n end\n add_branch(new_branch, opts.merge(add_remote_files_info: nil)) if add_branch\n\n add_remote_files?(new_branch, opts[:add_remote_files_info])\n end",
"def create_branch(name, target = 'upstream/master')\n # fetch the remote if defined in the target\n unless branch_exist?(name)\n remote_name, ref = target.split('/', 2)\n fetch(remote_name)\n logger.info(\"Creating branch: #{name} for #{path} from #{target}\")\n found_ref = find_ref(target)\n repo.create_branch(name, found_ref)\n else\n repo.branches[name]\n end\n end",
"def checkout(branch_name)\n local_branches = @rugged_repository.branches.each_name.to_a\n if !local_branches.include?(branch_name) && self.remote_branch_from_local(branch_name)\n @rugged_repository.branches.create(branch_name, self.remote_branch_from_local(branch_name))\n end\n @rugged_repository.checkout(branch_name)\n end",
"def has_update?(branch)\n zombie_check\n end",
"def push_branch\n return puts \"Not pushing, isn't a branch: #{@name}\" unless valid?\n\n puts \"Checking if we can push something on #{@source.name}\"\n return puts \"...nothing to push for #{@source.name}\" unless dirty? && valid?\n\n puts \"...pushing #{@source.name}[#{shortsha(@source.name)}]\"\n @git.push('origin', @source.name)\n @pushed = true\n end",
"def get_branch(branch)\n return @tree[branch] unless @tree[branch].blank?\n tmp = @store.read branch\n if tmp != false\n @tree[branch] = tmp\n return tmp\n end\n false\n end",
"def branch\n @env.fetch( :branch, \"N/A\" )\n end",
"def is_branch?(branch)\n branch_names = self.branches.map {|b| b.name}\n branch_names.include?(branch)\n end",
"def checkout(branch)\n zombie_check\n workdir = File.join(@repo.dir.to_s, \".worktree\", @name, branch)\n worktree = @repo.new_worktree(workdir, self.class.branch_name(@name, branch: branch)) \n end",
"def branch; end",
"def has_remote_tracking_branch(repo)\n return false if $branch_name.empty?\n\n begin\n return !repo.branches[$remote_branch].nil?\n rescue\n return false\n end\nend",
"def change_branch(name, update_branch = false)\n @handler.change_branch(name, update_branch)\n true\n rescue Repomen::HandlerError\n false\n end",
"def has_changes?(branch)\n zombie_check\n end",
"def on_branch?\n at_path do\n matches = git_with_identity('branch', '--no-color', '-a').match %r{\\*\\s+(.*)}\n matches[1] unless %r{(\\(detached from|\\(HEAD detached at|\\(no branch)}.match?(matches[1])\n end\n end",
"def create_branch\n sh 'git branch gh-pages'\n sh 'git checkout gh-pages'\n end",
"def exist?\n @grit && @grit.git.exists?\n end",
"def git_has_remote_branch?(branch)\n `git config branch.#{branch}.merge`.strip == ''\n end",
"def add_branch ret\n return if @branch.nil?\n return if ret.include? @branch\n ret << @branch\n @branch.reachable ret\n end",
"def check_branch(branch)\n \troom = false\n\t\treturn room if branch.nil?\n\n\t\t# Recurse through the tree to see if rooms exist\n\t\tbranch.children.each do |c|\n\t\t\tt_room = check_branch(c)\n\t\t\tif !t_room\n\t\t\t\t# If there is no room, remove the corridor\n\t\t\t\tc.cells.each { |cell| cell.type = Cell::UNALLOCATED }\n\t\t\telse\n\t\t\t\troom = true if !room\n\t\t\tend\n\t\tend\n\n\t\t# Due to corridor overlap, this makes sure the corridor gets rebuilt when a lower branch is wiped\n\t\tbranch.cells.last.type = Cell::CORRIDOR if room \n\n\t\t# True if a room\n\t\troom = branch.is_a?(RoomBranch) if !room\n\n return room\n\tend",
"def branch\n raise NotImplementedError\n end",
"def empty_branch?(branch)\n (is_branch & (1 << branch)) == 0\n end",
"def newMet\n puts \"Try to create a new branch and then push it back to remote\"\n end",
"def create_branch_and_checkout(repo_path, commit, branch)\n `(cd \"#{repo_path}\" && git checkout -b #{branch} #{commit})`\n end",
"def create\r\n if @current_shop.branches_count >= @current_shop.max_branches_count\r\n flash[:error] = t('You have no authories to create more branch.')\r\n redirect_to backend_shop_branches_path(@current_shop.slug)\r\n else\r\n @branch = @current_shop.branches.build(branch_params.except(:supported_order_types, :supported_scratchpad_order_types, :supported_send_sms_order_types))\r\n @branch.supported_order_types = params[:branch][:supported_order_types].nil? ?\r\n nil: params[:branch][:supported_order_types].select{|type| Order::order_types_array.index(type).present? }.join(',')\r\n @branch.supported_scratchpad_order_types = params[:branch][:supported_scratchpad_order_types].nil? ?\r\n nil: params[:branch][:supported_scratchpad_order_types].select{|type| Order::order_types_array.index(type).present? }.join(',')\r\n @branch.supported_send_sms_order_types = params[:branch][:supported_send_sms_order_types].nil? ?\r\n nil: params[:branch][:supported_send_sms_order_types].select{|type| Order::order_types_array.index(type).present? }.join(',')\r\n #@branch = @current_shop.branches.build(branch_params)\r\n respond_to do |format|\r\n if @branch.save\r\n format.html { redirect_to backend_shop_branch_branch_steps_path(@current_shop.slug, @branch) + \"/detail_info\" }\r\n format.json { render action: 'show', status: :created, location: @branch }\r\n else\r\n format.html { render action: 'new' }\r\n format.json { render json: @branch.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end\r\n end",
"def check_branch(branch)\n room = false\n return room if branch.nil?\n\n # Recurse through the tree to see if rooms exist\n branch.children.each do |c|\n t_room = check_branch(c)\n if !t_room\n # If there is no room, remove the corridor\n c.cells.each { |cell| cell.type = Cell::UNALLOCATED }\n else\n room = true if !room\n end\n end\n\n # Due to corridor overlap, this makes sure the corridor gets rebuilt when a lower branch is wiped\n branch.cells.last.type = Cell::CORRIDOR if room\n\n # True if a room\n room = branch.is_a?(RoomBranch) if !room\n\n return room\n end",
"def create_branch( tag=next_branch_tag(), sha=nil )\n if not sha\n sha = commits.last.id\n #sha = branches.first.commit.id if not sha\n end\n name = clean_tag(tag)\n update_ref(name, sha)\n name\n end",
"def new?\n master_path = File.join @path, %w[ .git refs heads master ]\n not File.exists? master_path\n end",
"def checkout_branch\n return unless self.working_directory\n\n commands = []\n if branch_exists?(self.branch)\n # Checkout the branch if it already exists\n commands << \"git checkout #{self.branch.shellescape}\"\n else\n # If a new branch is being created, we create it as an 'orphan' to not inherit changes from the master branch.\n commands << \"git checkout --orphan #{self.branch.shellescape}\"\n # We also need to reset the working directory to not transfer any uncommitted changes to the new branch.\n commands << \"git reset --hard\"\n end\n\n UI.message(\"Checking out branch #{self.branch}...\")\n\n Dir.chdir(self.working_directory) do\n commands.each do |command|\n FastlaneCore::CommandExecutor.execute(command: command,\n print_all: FastlaneCore::Globals.verbose?,\n print_command: FastlaneCore::Globals.verbose?)\n end\n end\n end",
"def intra_branch?(pr_id)\n q = <<-QUERY\n select IF(base_repo_id = head_repo_id, true, false) as intra_branch\n from pull_requests where id = ?\n QUERY\n if_empty(db.fetch(q, pr_id).all, :intra_branch)\n end",
"def set_branch\n @branch = Branch.get_branch(params[:id], params[:workspace_id]).first\n end",
"def create\n @branch = Branch.new(branch_params)\n\n respond_to do |format|\n if not session[:tipo_usuario] == 1\n format.html { redirect_to new_branch_path, notice: 'Solo el administrador puede crear una Sucursal' }\n #format.json { render :show, location: @branch } \n elsif @branch.save\n format.html { redirect_to @branch }\n format.json { render :show, status: :created, location: @branch }\n else\n format.html { render :new }\n format.json { render json: @branch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def git_checkout(branch = current_default_branch, create = false)\n if !create || `git branch -a`.split.collect {|l| l.gsub('remotes/origin/', '')}.sort.uniq.include?(branch)\n mysystem(\"git checkout #{branch} > /dev/null 2> /dev/null\")\n else\n mysystem(\"git checkout -b #{branch} > /dev/null 2> /dev/null\")\n end\n end",
"def intra_branch?(pr)\n q = <<-QUERY\n select IF(base_repo_id = head_repo_id, true, false) as intra_branch\n from pull_requests where id = ?\n QUERY\n db.fetch(q, pr[:id]).first[:intra_branch]\n end",
"def checkout(ref, branch: true)\n raise\n end",
"def create\n\n @branch = Branch.new(branch_params)\n\n respond_to do |format|\n if @branch.save\n format.html { redirect_to @branch, notice: 'Store branch was successfully created.' }\n format.json { render action: 'show', status: :created, location: @branch }\n else\n format.html { render action: 'new' }\n format.json { render json: @branch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def check_current_branch_task\n raise \"Currently not on #{local_branch} branch!\" unless `#{git} branch`.split(\"\\n\").detect { |b| /^\\* / =~ b } == \"* #{local_branch}\"\n end",
"def branch\n @branch ||= `git branch 2> /dev/null`[/\\*\\s(.+)$/, 1]\n end",
"def find_branch(repo, branch)\n name, num = branch.split('-')\n\n variations = [ branch, \"#{name}#{num}\", \"#{name}_#{num}\" ]\n\n branches = %x( cd #{repo} ; git branch --list ).gsub('*', '').split(\"\\n\")\n branches.each do |b|\n b.strip!\n variations.each do |v|\n return b if (b == v)\n end\n end\n\n return nil\nend",
"def saveas newbranch, message = nil\n message ||= \"Create new branch: #{newbranch}\"\n begin\n if @git.empty?\n # For an empty repo, we can \"create a new branch\" by setting HEAD to\n # a symbolic reference to the new branch. Then, the next commit will\n # create that branch (instead of master).\n Rugged::Reference.create(@git, 'HEAD',\n \"refs/heads/#{newbranch}\", true)\n else\n # For a non-empty repo, we just create a new branch and switch to it.\n branch = @git.create_branch newbranch\n @git.head = branch.canonical_name\n end\n rescue Rugged::ReferenceError => error\n case error.message\n when /is not valid/\n raise InvalidParameter, \"#{newbranch} is not a valid branch name\"\n when /already exists/\n raise InvalidParameter, \"#{newbranch} already exists\"\n else\n raise Error, \"Internal Rugged error: #{error.message}\"\n end\n end\n\n # Next, save any working changes.\n begin\n save message\n rescue NothingToCommitError\n # New changes are not required for saveas.\n end\n end",
"def exist?\n File.exist? File.join(path, '.git/HEAD')\n end",
"def backported_from_master?\n branch != 'origin/master' && self.class.exists?(:branch => 'origin/master', :message => message, :author => author)\n end",
"def change_branch_presence(branch_type, branch, presence)\n verb =\n if presence == :add\n 'restored'\n else\n 'deleted'\n end\n\n body = \"#{verb} #{branch_type} branch `#{branch}`\"\n\n create_note(NoteSummary.new(noteable, project, author, body, action: 'branch'))\n end",
"def delete_branch(name)\n repo.branches.delete(name)\n !branch_exist?(name)\n end",
"def branch?(sha)\n return false if sha.nil?\n return false unless sha = resolve(sha)\n return false unless commit = git.get(:commit, sha)\n \n blob = commit.tree/FILE\n blob && blob.data.empty? ? true : false\n end",
"def ask_for_branch(git,message)\n branch = git_branches(git)\n return branch[0] if branch.size == 1\n ask_for_item(message,branch)\n end",
"def saveas newbranch, message = nil\n message ||= \"Create new branch: #{newbranch}\"\n # First, create the new branch and switch to it.\n Dir.chdir @root do\n cmd = \"git checkout -b \\\"#{newbranch}\\\"\"\n stdout, stderr, status = Open3.capture3 cmd\n if status != 0\n case stderr\n when /not a valid branch name/\n raise InvalidParameter, \"#{newbranch} is not a valid branch name\"\n when /already exists/\n raise InvalidParameter, \"#{newbranch} already exists\"\n when /Not a git repository/\n raise NotARepositoryError\n else\n raise Error, stderr\n end\n end\n end\n # Next, save any working changes.\n begin\n Twit.save message\n rescue NothingToCommitError\n # New changes are not required for saveas.\n end\n end",
"def added?\n branch != BASE && !changed?\n end",
"def create\n @branch = Branch.new(branch_params)\n\n respond_to do |format|\n if @branch.save\n format.html { redirect_to @branch, notice: 'Branch was successfully created.' }\n format.json { render action: 'show', status: :created, location: @branch }\n else\n format.html { render action: 'new' }\n format.json { render json: @branch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n #@branch = Branch.new(params[:branch])\n\n respond_to do |format|\n if @branch.save\n format.html { redirect_to(@branch, :notice => 'Branch was successfully created.') }\n format.xml { render :xml => @branch, :status => :created, :location => @branch }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @branch.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create_branch\n @tree_class.new\n end",
"def is_local_branch?(branch)\n branch_names = self.branches.local.map {|b| b.name}\n branch_names.include?(branch)\n end",
"def exists?(id)\n return Regulate::Git::Interface.exists?(id)\n end",
"def check_branch_name\n if /#{BRANCH_PREFIX}-[0-9]+-#{TEAM_NAMES}/i !~ @git_branch\n @exit_value = 1\n return \"Bad branch name '#{@git_branch.chomp}'\\n\"\n end\nend",
"def create\n @page_title = t('branches.new.title') \n @branches = Branch.all \n @branch = Branch.new(params[:branch])\n respond_to do |format|\n if @branch.save\n flash[:notice] = t('branches.new.success', :branch_name => @branch.name)\n format.html { redirect_to(edit_branch_url(@branch)) }\n format.xml { render :xml => @branch, :status => :created, :location => @branch }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @branch.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create_module_and_branch?(opts = {})\n if module_obj = module_exists?\n module_branch_exists? || create_module_branch(module_obj)\n else\n create_module_and_branch(create_implementation: opts[:create_implementation])\n end\n end",
"def exists_including_main_branch?(binary_tx_hash)\n return true if exists?(binary_tx_hash)\n hex_hash = Toshi::Utils.bin_to_hex_hash(binary_tx_hash)\n tx = Toshi::Models::Transaction.from_hsh(hex_hash)\n return tx != nil && tx.in_view?\n end",
"def build_branch(branch, params = {}, body = {})\n CircleCi.request(conf, \"#{base_path}/tree/#{branch}\", params).post(body)\n end",
"def create_target?\n !(project.initialize_with_readme && target_branch == project.default_branch) && target_new_branch\n end",
"def create\n @branch = Branch.create(branch_params)\n if @branch.valid?\n render json: @branch, status: :accepted\n else\n render json: {errors: @branch.errors.full_messages}, status: :unprocessable_entity \n end\n end",
"def local_branch_revision?(revision = @resource.value(:revision))\n at_path { branches.include?(revision) }\n end",
"def sub_branch?\n !root?\n end",
"def one?\n when_branches.one?\n end",
"def __branch(arg)\n case arg\n when ::Hash then TupleScope.new(arg, [], self)\n else\n Kernel::raise NotImplementedError, \"Unable to branch with `#{arg}`\"\n end\n end",
"def new_branch_in(folder, levels = nil)\n return if flat?\n\n raise Errors::BranchError.new(dir: folder.path) if folder == terminal\n\n raise TreeLimitExceededError.new(tree: self) if folder.count >= folder_limit\n\n levels ||= levels_below folder\n new_branch = new_paths_in folder, levels\n @folders = folders[0..folders.index(folder)].concat new_branch\n folders.last.create!\n end",
"def create\n @branch = Branch.new(params[:branch])\n flash[:notice] = 'Branch was successfully created.' if @branch.save\n respond_with(@branch)\n end",
"def contains?(fileOrDir, branch: \"master\")\n zombie_check\n b = @repo.branch(self.class.branch_name(@name, branch: branch))\n tree = b.gcommit.gtree\n splits = File.split(fileOrDir)\n splits.shift() if splits[0] == \".\"\n splits.each do |segment|\n tree = tree.children[segment] unless tree == nil \n end\n return tree != nil\n end",
"def set_branch\n branch = Branch.find(params[:id])\n end",
"def build_branch(branch, params = {}, body = {})\n CircleCi.request(@conf, \"/project/#{username}/#{project}/tree/#{branch}\", params).post(body)\n end",
"def create\n @branch = current_user.branches.new(branch_params)\n\n respond_to do |format|\n if @branch.save\n Tools.write2log(current_user.id, 'Добавление', 'Филиалы', 0, branch_params.to_s)\n format.html { redirect_to branches_path, notice: 'Филиал был успешно добавлен.' }\n format.json { render action: 'show', status: :created, location: @branch }\n else\n Tools.write2log(current_user.id, 'Добавление', 'Филиалы', 1, branch_params.to_s)\n format.html { render action: 'new' }\n format.json { render json: @branch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def check_node_link(branch, stack)\n begin\n return get_node.check_node_link(branch, stack)\n rescue\n return false\n end\n end",
"def clean_local_branch\n run_and_success?(\"#{git} show-branch #{ref} > /dev/null 2>&1 && #{git} branch -D #{ref} > /dev/null 2>&1\")\n end",
"def is_origin_branch? branch\n branches ||= %x{git branch -r}.split # yeah, slow. should we cache it?\n branches.include? \"origin/#{branch}\"\nend",
"def create\n @branch = Branch.new(branch_params.map{|k,v| {k.to_sym => v.class == ActionController::Parameters ? [v.to_hash] : v.to_s}}.reduce({}, :merge))\n\n respond_to do |format|\n if @branch.save\n format.html { redirect_to @branch, success: 'Branch was successfully created.' }\n format.json { render :show, status: :created, location: @branch }\n else\n format.html { render :new }\n format.json { render json: @branch.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pr_is_intra_branch(req)\n return false unless pr_has_head_repo(req)\n\n if req['head']['repo']['owner']['login'] ==\n req['base']['repo']['owner']['login'] and\n req['head']['repo']['full_name'] == req['base']['repo']['full_name']\n true\n else\n false\n end\n end",
"def detached_head?\n rebased_branch.empty?\n end",
"def in_branch(message = nil)\n old_ref = @repo.head\n checkout\n yield @repo\n\n if message\n @repo.commit_index message\n @repo.head.commit\n end\n ensure\n old_ref.checkout\n end",
"def delete_branch(branch_name)\n # Delete local branch if it exists.\n git_call(\"branch -D #{branch_name}\", true) if branch_exists?(:local, branch_name)\n # Delete remote branch if it exists.\n git_call(\"push origin :#{branch_name}\", true) if branch_exists?(:remote, branch_name)\n end",
"def new_issue_branch(branch, branch_project: nil)\n branch_project ||= project\n link = url_helpers.project_compare_path(branch_project, from: branch_project.default_branch, to: branch)\n\n body = \"created branch [`#{branch}`](#{link}) to address this issue\"\n\n create_note(NoteSummary.new(noteable, project, author, body, action: 'branch'))\n end"
] |
[
"0.7477726",
"0.7319752",
"0.7282876",
"0.7063241",
"0.69429773",
"0.6899303",
"0.6818747",
"0.67144597",
"0.67061746",
"0.6641557",
"0.66340685",
"0.6623382",
"0.65888405",
"0.6588591",
"0.65870833",
"0.6571904",
"0.65333396",
"0.64871174",
"0.64258677",
"0.64155406",
"0.6394956",
"0.6370822",
"0.63374734",
"0.63132423",
"0.62986964",
"0.6261849",
"0.6237898",
"0.6177863",
"0.6165932",
"0.60426205",
"0.6041799",
"0.60369736",
"0.60338897",
"0.6031176",
"0.60100627",
"0.5989838",
"0.5982732",
"0.59817517",
"0.5979534",
"0.59605914",
"0.5959785",
"0.59542936",
"0.5952225",
"0.59149086",
"0.5903503",
"0.58872545",
"0.58846265",
"0.5878111",
"0.58539844",
"0.5845976",
"0.5841063",
"0.58347976",
"0.5822742",
"0.58201545",
"0.58039606",
"0.5800894",
"0.5794619",
"0.5771364",
"0.57558614",
"0.57557654",
"0.57412314",
"0.57387024",
"0.57360053",
"0.57293415",
"0.57194674",
"0.57107157",
"0.5701327",
"0.5689923",
"0.56871545",
"0.5685998",
"0.5678122",
"0.56764007",
"0.5673918",
"0.56687903",
"0.5667879",
"0.56651676",
"0.56628937",
"0.56480396",
"0.56428826",
"0.564187",
"0.56327724",
"0.5623108",
"0.5618894",
"0.5609193",
"0.56011397",
"0.55818355",
"0.55681896",
"0.5566522",
"0.556519",
"0.55592924",
"0.5556",
"0.55531806",
"0.55377775",
"0.5534481",
"0.5532776",
"0.5527309",
"0.5524773",
"0.550478",
"0.54979914",
"0.5489449",
"0.5486133"
] |
0.0
|
-1
|
Method that checks and adds or not the remote github url
|
def add_remoteurl(dir)
vConfig(CONFIG['configWebsite'])
read_json(CONFIG['configWebsite'])
remoteURL = @parse_json_config['deploy']['github']['config']['remoteURL']
remoteVerify = `sed -n '/url/p' #{dir}/.git/config | cut -d'=' -f2 | cut -d' ' -f2`
if remoteVerify.nil? || remoteVerify.empty?
system_commands("cd #{dir}; git remote add origin #{remoteURL}")
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def has_github?\n !github_url.blank?\n end",
"def github_url\n [homepage, source_code_uri].find do |url|\n GemsBond::Fetchers::Github.valid_url?(url)\n end\n end",
"def harmonize_remote_url(expected_url)\n remote_url = Cocaine::CommandLine.new(\"git config --get remote.origin.url\").run.chomp\n if remote_url != expected_url\n puts \"#{remote_url.inspect} does not match #{expected_url.inspect}. Updating it.\"\n Cocaine::CommandLine.new(\"git remote\", \"set-url origin #{expected_url}\").run\n end\n end",
"def github_check\n begin\n unless github.blank?\n RestClient.get \"https://github.com/#{github}\"\n end\n rescue\n errors.add :base, \"Invalid Github account.\"\n end\n end",
"def normalize_github_url\n return if self.github_url.blank?\n\n url = self.github_url || \"\"\n url.gsub!(/(https?:\\/\\/)?(www\\.)?github\\.com\\//, \"\")\n self.github_url = \"https://github.com/#{url}\"\n true\n end",
"def github_repo?\n @url.scan('https://github.com/').present?\n end",
"def github_url\n @github_url ||= \"https://github.com/#{options[:github_owner]}/#{name}\"\n end",
"def check_if_push_allowed\n if @source.is_a?(CDNSource)\n raise Informative, 'Cannot push to a CDN source, as it is read-only.'\n end\n\n remotes, = Executable.capture_command('git', %w(remote --verbose), :capture => :merge, :chdir => repo_dir)\n master_repo_urls = [\n 'git@github.com:CocoaPods/Specs.git',\n 'https://github.com/CocoaPods/Specs.git',\n ]\n is_master_repo = master_repo_urls.any? do |url|\n remotes.include?(url)\n end\n\n if is_master_repo\n raise Informative, 'To push to the CocoaPods master repo use ' \\\n \"the `pod trunk push` command.\\n\\nIf you are using a fork of \" \\\n 'the master repo for private purposes we recommend to migrate ' \\\n 'to a clean private repo. To disable this check remove the ' \\\n 'remote pointing to the CocoaPods master repo.'\n end\n end",
"def remote?\n !(url =~ /^https?/).nil?\n end",
"def update_remote(path, git_remote)\n updated = false\n\n Dir.chdir(path) do\n @logger.debug(\"update git remote urls for #{path}\")\n\n git_remote.each do |remote_name, remote_url|\n stdout, _stderr, _status = Open3.capture3(\"git remote get-url #{remote_name}\")\n\n current_remote_url = stdout.strip\n\n next if remote_url.nil? || current_remote_url == remote_url\n\n `git remote remove #{remote_name}` unless current_remote_url.empty?\n\n `git remote add #{remote_name} #{remote_url}`\n\n updated = true\n end\n end\n\n updated\n end",
"def github_url\n github_user.blank? ? nil : \"#{GITHUB_URL}#{github_user}\"\n end",
"def url_exists?(github_url)\n url = URI.parse(github_url)\n req = Net::HTTP.new(url.host, url.port)\n req.use_ssl = true\n res = req.request_head(url.path)\n if res.is_a?(Net::HTTPRedirection)\n url_exist?(res['location']) # Go after any redirect and make sure you can access the redirected URL\n else\n res.code[0] != '4' # false if http code starts with 4 - error on your side.\n end\nrescue Errno::ENOENT\n false # false if can't find the server\nend",
"def perform_github_source_checks(s)\n require 'uri'\n\n if git = s[:git]\n return unless git =~ /^#{URI.regexp}$/\n git_uri = URI.parse(git)\n if git_uri.host\n perform_github_uri_checks(git, git_uri) if git_uri.host.end_with?('github.com')\n end\n end\n end",
"def access_to_repo?(repo_url: nil)\n client.repository?(repo_url.sub(\"https://github.com/\", \"\"))\n end",
"def giturl(project_name, repo_name) ; end",
"def git_url?(url)\n url.include?('.git') || url.include?('git@') || url.include?('git://')\n end",
"def add_from_github(issue_num)\n github_url = 'https://api.github.com/repos/acceptbitcoincash/acceptbitcoincash/issues'\n uri = URI(\"#{github_url}/#{issue_num}\")\n puts 'pulling issue from repository'\n issue = Net::HTTP.get(uri)\n issue = JSON.parse(issue)\n category = get_category(issue['labels'])\n request = SafeYAML.load(extract_issue_yml(issue['body']))[0]\n\n section, websites = read_yaml(category, 'websites')\n unless valid_to_ins(websites, request, 'name')\n puts 'Duplicate of entry, update functionality not yet available'\n return false\n end\n\n if request['img'].nil?\n request['img'] = value_prompt(\"image name for #{request['name']}\")\n elsif request['img'].include? 'http'\n puts \"Download the image from #{request['img']}\"\n request['img'] = value_prompt('image name')\n end\n puts \"Be sure you saved the logo to img/#{category}/#{request['img']}\" \\\n unless img_exists?(category, request['img'])\n\n section['websites'] = add_and_sort(websites, request, 'name')\n if valid_revision(section)\n write_yaml(category, section)\n true\n else\n puts 'Invalid entry, try changing the data before trying again.'\n false\n end\n end",
"def github\n Log.fatal('You did not configure GitHub yet.') unless @github\n @github\n end",
"def update_remote(remote, remote_name='origin')\n if @_rugged_repo\n logger.debug2(_(\"Remote URL is different from cache, updating %{orig} to %{update}\") % {orig: remotes[remote_name], update: remote})\n @_rugged_repo.remotes.set_url(remote_name, remote)\n end\n end",
"def is_file_source_a_remote_url?\n !self.remote_url.blank?\n end",
"def ensure_cloned(repository_url)\n repository_url && :not_implemented\n end",
"def github_url\n \"https://github.com/#{self.nickname}\"\n end",
"def set_remote\n return if @remote_type == :none\n\n url = \"git@github.com:pixelastic/#{@name}.git\" if @remote_type == :github\n if @remote_type == :bitbucket\n url = \"git@bitbucket.org:pixelastic/#{@name}.git\"\n end\n\n if create_remote('origin', url)\n puts '✔ Configuring remote'\n else\n puts '✘ Failed to configure remote'\n exit 1\n end\n end",
"def has_github?\n github_identity.present?\n end",
"def repo_github_path\n descrip = %x{git remote -v}.match(/^.+git@github\\.com:(.+\\/.+)\\.git/)\n raise \"Could not find a Github remote\" if descrip.nil?\n descrip[1]\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 make_url_available_to_remote(local_url)\n end",
"def is?(url)\n return true if url.match('https?://github\\.com/(.+)/(.+)')\n end",
"def github_repo\n self.github_url&.gsub(\"https://github.com/\", \"\")\n end",
"def push_repo_to_github?\n DeliveryGolang::Helpers::Publish.push_repo_to_github?(node)\n end",
"def push_repo_to_github?(node)\n !!node['delivery']['config']['build_attributes']['publish']['github']\n rescue\n false\n end",
"def on_github?\n response = github_client_request(client, id, headers: GitHub::APIHeaders.no_cache_no_store)\n response ||= github_classroom_request(id, headers: GitHub::APIHeaders.no_cache_no_store)\n response.present?\n end",
"def git_remote_add(remote_name, remote_url)\n cmd = \"#{discover_git_executable} remote add upstream \\\"#{remote_url}\\\"\"\n debug \"Running #{cmd} 2>&1\"\n output = %x[#{cmd} 2>&1]\n raise RHC::GitException, \"Error while adding upstream remote - #{output}\" unless output.empty?\n end",
"def set_upstream(clone_path, upstream_url)\n remotes = `cd #{clone_path} && git remote -v`\n unless remotes.include?('upstream')\n puts `cd #{clone_path} && git remote add upstream #{upstream_url}`\n end\nend",
"def linked_github_account?\n accounts.for(\"github\").any?\n end",
"def base_github_api_url_for_remote\n url = gitlib.remote.expanded_url(remote_name)\n Configuration.url_to_base_github_api_url(url)\n end",
"def enabled?\n (super ||\n !@remote_path.nil? && @remote_path.directory? ||\n local_valid_repo?)\n end",
"def authorized_for_github?\n !github.nil?\n end",
"def add_remote(name, url, opts = {})\n url = url.repo.path if url.is_a?(Git::Base)\n self.lib.remote_add(name, url, opts)\n Git::Remote.new(self, name)\n end",
"def has_remote_tracking_branch(repo)\n return false if $branch_name.empty?\n\n begin\n return !repo.branches[$remote_branch].nil?\n rescue\n return false\n end\nend",
"def url\n \"http://github.com/#{repo.owner.login}/#{repo.name}/#{name}\"\n end",
"def check_repo(url)\n output = `git ls-remote #{url} 2>&1`\n if ($? != 0)\n raise BadRepo.new(url + \"<<<\" + output.to_s + \">>>\")\n end\n end",
"def use_github?\n !journal_biohackrxiv?\n end",
"def remote?\n !@remote.nil?\n end",
"def add_git_facts\n # see if we're in a git repo. first, we need a directory that exists\n dir = @path.expand_path.ascend.find {|p| p.directory? }\n \n Dir.chdir(dir) do\n root_result = Cmds.new \"git rev-parse --show-toplevel\"\n \n unless root_result.ok?\n @result.in_git_repo = false\n @result.is_git_root = false\n return\n end\n \n @result.in_git_repo = true\n \n git = @result.git = Result.new\n git.root = Pathname.new root_result.out.chomp\n @result.is_git_root = @path == git.root\n \n user = git.user = Result.new\n \n ['name', 'email'].each {|key|\n user[key] = begin\n Cmds.chomp! \"git config user.#{ key }\"\n rescue\n end\n }\n \n git.origin = begin\n Cmds.chomp! \"git remote get-url origin\"\n rescue\n end\n \n match = GITHUB_SSH_URL_RE.match(git.origin) ||\n GITHUB_HTTPS_URL_RE.match(git.origin)\n \n git.is_github = !! match\n \n return unless match\n \n git.owner = match['owner']\n git.name = match['name']\n git.full_name = \"#{ git.owner }/#{ git.name }\"\n \n if true == @args['github_api']\n github = git.github = Result.new\n github.api_url = \"https://api.github.com/repos/#{ git.owner }/#{ git.name }\"\n \n response = Net::HTTP.get_response URI(github.api_url)\n \n if response.is_a? Net::HTTPSuccess\n # parse response body and add everything to github result\n parsed = JSON.parse response.body\n parsed.each {|k, v| github[k] = v}\n else\n # assume it's private if we failed to find it\n github.private = true\n end\n \n end\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 validate_target_remote_branch\n remote_path = File.join(config[:remote], config[:branch])\n\n remotes = []\n @gitrepo.remotes.each { |remote| remotes << remote.name }\n unless remotes.include?(remote_path)\n ui.error 'The remote/branch specified does not seem to exist.'\n exit 7\n end\n end",
"def github_url_matching(url)\n matches = /github\\.com.(.*?)\\/(.*)/.match(url)\n matches ? [matches[1], matches[2].sub(/\\.git\\z/, '')] : [nil, nil]\n end",
"def github_domain?\n !!domain.match(/\\.github\\.com$/)\n end",
"def git_url_must_be_valid\n matched = false\n\n [/^https?:\\/\\/.+\\.git$/i, /^git@.+:.+\\.git$/i].each do |valid_form|\n if valid_form.match git_url\n matched = true\n break\n end\n end\n\n unless matched\n errors.add(:git_url, 'must be of form http[s]://host/path/to/repository.git OR git@host:path/to/repository.git')\n end\n end",
"def update_github\n unless environment_is_production\n puts 'NOT updating github because environment is not production'\n return false\n end\n\n puts 'pushing database to github'\n\n @scraper_log.info \"------------------------------\"\n @scraper_log.info \"updating git\"\n @scraper_log.info \"------------------------------\"\n x = Subexec.run \"git add #{@db_dump_file} #{@status_file_name}\"\n x = Subexec.run \"git commit -m 'Updated database dump file and status.json with new hr.gov.ge data'\"\n x = Subexec.run \"git push origin master\"\nend",
"def url\n \"http://github.com/#{login}\"\n end",
"def github_url\n case protocol\n when :ssh\n \"git@github.com:#{repo_identifier}.git\"\n when :https\n \"https://github.com/#{repo_identifier}.git\"\n when :git\n \"git://github.com/#{repo_identifier}.git\"\n else\n raise UnknownGitHubProtocol.new(protocol)\n end\n end",
"def url_of_git_repo(remote_name)\n `git config remote.#{remote_name}.url`.strip\n end",
"def call\n if git_remote_command =~ /git@github.com:(.+).git/\n \"https://github.com/#{Regexp.last_match(1)}\"\n else\n git_remote_command.sub('.git', '').chomp\n end\n end",
"def profile_exists? github_id\n # Commenting this out because it takes too much time to verify in India\n # 2/4/2015 @vyder\n # TODO: Make this check optional\n true\n # http_status_code = %x( curl -s -o /dev/null -w \"%{http_code}\" https://github.com/#{github_id})\n #\n # http_status_code == \"200\"\nend",
"def add_remote(uri, name)\n @repository.add_remote(name,uri)\n \n self.remotes\n end",
"def remote_repository_access?\n configuration[:remote_repository_access] == true\n end",
"def github_url\n GITHUB_ARTICLES_URL + file_name\n end",
"def gitorious_remote_url\n output = `git remote -v`.scan(/^#{remote}\\s+(.*).git(.*)/)\n if output\n output.first[0]\n end\n end",
"def check_git_ssh_source(s)\n if git = s[:git]\n if git =~ %r{\\w+\\@(\\w|\\.)+\\:(/\\w+)*}\n results.add_warning('source', 'Git SSH URLs will NOT work for ' \\\n 'people behind firewalls configured to only allow HTTP, ' \\\n 'therefore HTTPS is preferred.', true)\n end\n end\n end",
"def usable_repository?\n repository_cache.directory? &&\n run_and_output(\"#{git} remote -v | grep origin\").include?(uri)\n end",
"def save_git_url\n puts \"\\nPlease enter your #{@git_service} url :\"\n puts 'example: http://gitlab.example.com/'\n puts '-----------------------------------'\n\n begin\n input = STDIN.gets.chomp\n exit! if input == 'quit'\n # force scheme if not specified\n # TODO - Find a way to clear this... Find the correct scheme.\n if input.start_with?('gitlab.com')\n input = \"https://#{input}\"\n elsif !input.start_with?('http://', 'https://')\n input = \"http://#{input}\"\n end\n # Call the entered url to know if it exist or not.\n # If not, would raise an exception\n get(url: input)\n input\n rescue Interrupt\n exit!\n rescue Exception\n puts \"\\nOops, seems to be a bad url. Try again or quit (quit)\"\n save_git_url\n end\n end",
"def url_from_github_upload_url(string)\n match = string.match(/^!\\[.*\\]\\((https:\\/\\/\\S*)\\)$/)\n match[1] unless match.nil?\n end",
"def add_remote(name, url)\n remotes.create name, url\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 update_repo\n puts \"starting to update_repo: '#{self.ident}'\"\n github = JSON.parse(Curl::Easy.perform(\"https://api.github.com/repos/\" + self.ident).body_str)\n \n if github[\"message\"]\n # Something has gone wrong\n # probably: repo does not exist\n # => 1) incorrect information provided when adding a repo\n # => 2) previously existing repo has had some changes (e.g. name, ownership)\n return false\n # do: better error handling here\n # what happens if a repo has been renamed / ownership transferred / deleted\n # => set flag 'needs_an_eye' to true\n # => then jump to the next repo\n # => might be done using 'markable' gem\n else\n %w{name description homepage}.each do |field|\n # set field or fall back to defaults\n self[field] = github[field] || \"\"\n end\n %w{watchers forks}.each do |field|\n # set field or fall back to defaults\n self[field] = github[field] || 0\n end\n\n self.github_url = github[\"html_url\"]\n self.owner = github[\"owner\"][\"login\"]\n self.last_updated = github[\"pushed_at\"]\n self.save\n end\n end",
"def remote?\n @remote\n end",
"def github_updates_url(upstream='master', commit=Rails.application.current_commit)\n github_url \"compare/#{commit}...#{upstream}\"\n end",
"def remote?\n %w[http https].include? scheme\n end",
"def fetch?\n remote?\n end",
"def remote\n grit.config[\"branch.#{branch}.remote\"] || 'origin'\n end",
"def github_fetcher\n return @github_fetcher if defined?(@github_fetcher)\n\n @github_fetcher = github_url && GemsBond::Fetchers::Github.new(github_url).tap(&:start)\n end",
"def groupon_path(repo)\n github = \"github.groupondev.com\"\n ENV[\"INTERNAL_GEMS_OVER_SSH\"] ? \"git@#{github}:#{repo}.git\" : \"https://#{github}/#{repo}.git\"\nend",
"def remote_repository\n \"http://www.aQute.biz/repo\"\n end",
"def pull_request?\n !!issue.pull_request.html_url\n end",
"def pull_request?\n !!issue.pull_request.html_url\n end",
"def call(path: Dir.pwd)\n git = git_open(path)\n return @error unless git\n\n remote = git.remotes.find { |r| r.name == @config['source_name'] }\n remote ||= git_remote_add(git)\n return @error unless remote\n\n return @error unless git_remote_update(remote)\n\n { success?: true }\n end",
"def add_origin_url origin_url\n\n path_to_dot_git = File.join( @git_folder_path, \".git\" )\n git_add_origin_loggable_cmd = \"git --git-dir=#{path_to_dot_git} --work-tree=#{@git_folder_path} remote add origin\"\n git_add_origin_cmd = \"#{git_add_origin_loggable_cmd} #{origin_url}\"\n log.info(x) { \"[git] add origin command without url => #{git_add_origin_loggable_cmd}\" }\n %x[#{git_add_origin_cmd}];\n log.info(x) { \"[git] has added a remote origin url.\" }\n\n end",
"def fetch_over_http(repo_url, use_ssl, remote_name)\n # refs : 909e4d4f706c11cafbe35fd9729dc6cce24d6d6f refs/heads/master\n # packs: P pack-8607f42392be437e8f46408898de44948ccd357f.pack\n \n success = true\n \n Dir.chdir(@git_dir) do\n # fetch (url)/info/refs\n log('fetching server refs')\n refs = Net::HTTP.get(URI.parse(\"#{repo_url}/info/refs\")) \n fetch_refs = map_refs(refs)\n\n # fetch (url)/HEAD, write as FETCH_HEAD\n log('fetching remote HEAD')\n remote_head = Net::HTTP.get(URI.parse(\"#{repo_url}/HEAD\"))\n if !(remote_head =~ /^ref: refs\\//)\n fetch_refs[remote_head] = false\n else\n success = remote_head.sub('ref: refs/heads/', '').strip\n end\n\n fetch_refs.each do |sha, ref|\n log(\"fetching REF : #{ref} #{sha}\")\n if http_fetch(repo_url, sha, 'commit')\n update_ref(\"refs/remotes/#{remote_name}/#{ref}\", sha) if ref\n else\n success = false\n end\n end\n end\n \n success\n end",
"def has_repo?(local_param)\n !list.find { |r| r.param == local_param }.nil?\n end",
"def github_pr_checks_url(suite)\n return unless pr = suite.fetch(:pull_requests).first\n \"#{pr[:url].sub('://api.', '://').sub('/repos/', '/').sub('/pulls/', '/pull/')}/checks\"\n end",
"def valid_git_ssh_url?(url)\n url.match(GIT_SSH_URL_REGEX)\n end",
"def attempt_to_pull_using_http_auth(remote_name = 'origin', pull_options = '')\n # in most case, credentials of #{remote_name} has already been cached\n # so pull first, to see if there are any errors showing up\n\n pull_success, error_msg = git_fetch(remote_name, pull_options)\n\n return true if pull_success\n\n # we have errors then we will using configured credentials\n # or inform user to update, then try again\n\n remote_url = `git remote get-url #{remote_name}`.strip\n\n processed_remote_url, credential_exists,\n repo_username_key, repo_password_key = get_remote_credentials(remote_url)\n\n # if it is not https format\n # we will assume it is ssh format and the pull has fail\n if processed_remote_url.nil?\n fail_to_pull(remote_url)\n else\n # otherwise\n # it is https url\n\n # and only pull again if credentials are still exists\n if credential_exists\n @logger.debug \"Attempting to pull #{remote_name}:#{remote_url} again\"\n\n `git remote set-url #{remote_name} #{processed_remote_url}`\n\n pull_success, = git_fetch(remote_name)\n\n return true if pull_success\n\n # still fail then the credentials user provided are not correct\n credentials_are_present_but_fail_to_pull(remote_url,\n repo_username_key,\n repo_password_key)\n else\n # if credentials are not exists then inform user about it\n\n # we has internet but unable to connect\n if error_msg.to_s.match?('fatal: unable to access')\n fail_to_pull(remote_url)\n # we has no internet or has no credentials\n else\n internet_down_or_credential_not_found_to_pull(remote_url,\n repo_username_key,\n repo_password_key)\n end\n end\n end\n\n return false\n end",
"def remote?\n true\n end",
"def disabled?\n !github_repository.on_github? || !github_user.on_github?\n end",
"def remote? # :nodoc:\n @remote\n end",
"def git_clone_or_pull(repo,dest,ref=\"master\")\n run \"#{sudo} mkdir -p #{File.dirname(dest)}; #{sudo} chown -R #{user} #{File.dirname(dest)}\"\n cmd = compressed_join %Q{\n if [ -d #{dest} ]; then\n cd #{dest};\n git fetch;\n else\n git clone #{repo} #{dest};\n cd #{dest};\n git checkout -b deploy;\n fi\n }\n run_with_input(cmd,%r{\\(yes/no\\)}, \"yes\\n\")\n run_compressed %Q{\n if [ `cd #{dest} && git tag | grep -c #{ref}` = '1' ]; then\n cd #{dest}; git reset --hard #{ref};\n else\n cd #{dest}; git reset --hard origin/#{ref};\n fi\n }\n end",
"def push_to_repo\n return if @remote_type == :none\n\n if @remote_type == :bitbucket\n puts 'Cannot automatically create BitBucket repository.'\n puts 'Please, open it manually at https://bitbucket.org/repo/create'\n `#{ENV['BROWSER']} https://bitbucket.org/repo/create`\n return\n end\n\n return unless %i[github].include?(@remote_type)\n\n gh_options = [\n @name,\n ]\n gh_options << '--team algolia' if @is_algolia\n\n if @is_private\n gh_options << '--private'\n else\n gh_options << '--public'\n end\n\n command = \"gh repo create #{gh_options.join(' ')}\"\n\n if command_success?(command)\n puts '✔ Creating GitHub repository'\n else\n puts '✘ Failed to create GitHub repository'\n exit 1\n end\n\n if command_success?('git push origin main')\n puts '✔ Pushed to repository'\n else\n puts '✘ Failed to push to repository'\n exit 1\n end\n end",
"def github_url(payload)\n if(payload.get(:data, :code_fetcher, :info, :private))\n uri = URI.parse(payload.get(:data, :code_fetcher, :info, :url))\n uri.scheme = 'https'\n uri.user = config.fetch(:github, :access_token,\n app_config.get(:github, :access_token)\n )\n uri.to_s\n else\n payload.get(:data, :code_fetcher, :info, :url)\n end\n end",
"def fetch_from_github\n repo, branch, path = Post.parse_github_url self.github\n Environment.github.contents repo, ref: branch, path: path\n end",
"def attempt_to_clone_using_http_auth?(remote_url, dir)\n processed_remote_url, credential_exists,\n repo_username_key, repo_password_key = get_remote_credentials(remote_url)\n\n # if it is not https format\n # we will assume it is ssh format and use normal clone\n if processed_remote_url.nil?\n clone_success, = git_clone(remote_url, dir)\n\n return true if clone_success\n\n fail_to_access(remote_url)\n else\n # otherwise\n # it is https url\n # and wheter it has credentials or not, still clone it\n\n @logger.info(\"Attempting to using your configured credentials for #{remote_url}\")\n\n clone_success, error_msg = git_clone(processed_remote_url, dir)\n\n return true if clone_success\n\n # we fail, so raise corresponding messages\n\n # we has credentials\n if credential_exists\n credentials_are_present_but_fail_to_access(remote_url,\n repo_username_key,\n repo_password_key)\n else\n # we has internet but unable to connect\n if error_msg.match?('fatal: unable to access')\n fail_to_access(remote_url)\n # we has no internet or has no credentials\n else\n internet_down_or_credential_not_found_to_access(remote_url,\n repo_username_key,\n repo_password_key)\n end\n end\n end\n\n return false\n end",
"def github(name, ref = 'master')\n gitrepo \"github.com\", name, ref\nend",
"def pr_has_head_repo(req)\n not req['head']['repo'].nil?\n end",
"def name_to_url(name)\n \"https://github.com/#{name}.git\"\n end",
"def github_pull\n Extension.github_sync\n end",
"def fetch_details_from_github\n\t\t# To Do\n\t\tself.user.has_github = true\n\t\tself.user.save\n\tend",
"def github_url\n \"http://github.com/280north/cappuccino/commit/#{sha1}\"\n end",
"def verify_repo_exists(config)\n build_client(config).repo config[:repo]\n end",
"def configured_uri_for(uri)\n uri = uri.gsub(\"git@github.com:\", \"https://github.com/\")\n if /https?:/ =~ uri\n remote = URI(uri)\n config_auth =\n Bundler.settings[remote.to_s] || Bundler.settings[remote.host]\n remote.userinfo ||= config_auth\n remote.to_s\n else\n uri\n end\n end"
] |
[
"0.76588166",
"0.71272326",
"0.7058315",
"0.7052431",
"0.70423794",
"0.69761235",
"0.69377404",
"0.66902834",
"0.6660783",
"0.66258305",
"0.6621216",
"0.6594847",
"0.653276",
"0.65156406",
"0.65015984",
"0.64983886",
"0.6460231",
"0.6424185",
"0.64228576",
"0.6418765",
"0.6412381",
"0.639169",
"0.6378653",
"0.63741755",
"0.63227475",
"0.6305739",
"0.6301603",
"0.62949926",
"0.6273885",
"0.6252492",
"0.62304354",
"0.62119466",
"0.6203459",
"0.6191697",
"0.6190877",
"0.61879665",
"0.6184611",
"0.6177876",
"0.6163642",
"0.61595976",
"0.61583376",
"0.6157641",
"0.61370003",
"0.61279476",
"0.61234343",
"0.6114962",
"0.6103415",
"0.6088818",
"0.60767233",
"0.60721123",
"0.6042247",
"0.6038271",
"0.6035078",
"0.601895",
"0.6017382",
"0.60172844",
"0.60088515",
"0.6008448",
"0.6004781",
"0.6002853",
"0.59965307",
"0.5994706",
"0.5992394",
"0.598166",
"0.59750575",
"0.59621835",
"0.5940741",
"0.593942",
"0.5934181",
"0.5925043",
"0.5920052",
"0.590766",
"0.58891267",
"0.5887339",
"0.58824134",
"0.5872488",
"0.5872488",
"0.5868403",
"0.5866498",
"0.5865316",
"0.5862487",
"0.5860497",
"0.5858354",
"0.5857622",
"0.58552307",
"0.58392227",
"0.58357525",
"0.58349997",
"0.5804407",
"0.5787114",
"0.57717097",
"0.5762399",
"0.57600605",
"0.5759606",
"0.5756407",
"0.5752358",
"0.5732368",
"0.5720415",
"0.5714975",
"0.57126254"
] |
0.746424
|
1
|
Method that starts the deploy of the compiled project
|
def deploySite
verifyOS
timeDate = Time.new
vConfig(CONFIG['configWebsite'])
read_json(CONFIG['configWebsite'])
compileP = @parse_json_config['deploy']['compile']['built']
branchBuilt = @parse_json_config['deploy']['branch']['built']
msgCommit = @parse_json_config['deploy']['github']['config']['commit']
if compileP == "yes"
system_commands("rake build")
end
# enter_folder("./_site") # DEPRECATED
add_repo_git(SITEDIR)
add_remoteurl(SITEDIR)
pull_execute(branchBuilt, SITEDIR)
system_commands("echo Deploy source files. Wait ...")
git_checkout(branchBuilt, SITEDIR)
system_commands("cd #{SITEDIR}; git add .")
system_commands("cd #{SITEDIR}; git commit -m \"#{msgCommit} - #{timeDate.inspect}\"")
system_commands("cd #{SITEDIR}; git push origin -u #{branchBuilt}")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def deploy()\n release = create_release_name()\n\n write_deploy_version_file()\n\n DirectorySync.sync(server, from_dir, cache_dir, server[:deployer])\n copy_cache_dir_to_release(release)\n\n symlink_shared_directories(release)\n\n send_scripts()\n run_script(:before, release)\n symlink_release_dir(release)\n run_script(:after, release)\n end",
"def deploy\n if phase.has_key?('deploy')\n execute(\"deploy\", phase['deploy'])\n end\n end",
"def deploy\n @operation = \"Deploy\"\n build_env = project[:build_env] || \"\"\n\n prepare_local_dir do\n run_cmd \"cap -q deploy #{build_env}\"\n run_cmd \"cap -q deploy:migrate #{build_env}\"\n run_cmd \"cap -q deploy:cleanup #{build_env}\"\n end\n end",
"def perform_deployment\n \tself.started_at = Time.now \t\n \tline = Cocaine::CommandLine.new(\"cd /home/mohkhan.Desktop/SFDC_DeplomentScripts && perl fetch_and_deploy.pl -r #{self.release} -d <#{self.target_config_name}> --mode=#{self.mode}\")\n \tline.run\n \tself.ended_at = Time.now\n \tself.status = \"deployed\"\n \tself.save\n end",
"def deploy\n unless ITEMS[:project].has_value? SETTINGS[:project]\n raise \"Invalid project: #{SETTINGS[:project]}.\"\n end\n\n # Call the original deploy method.\n orig_deploy\n end",
"def deploy_application\n deploy(selfdir + \"app\")\n end",
"def deploy\n Kb8Run.update_context(@kb8context)\n @deploy_units.each do | deploy_unit |\n deploy_unit.deploy\n end\n end",
"def deploy\n update_repositories\n sync_service_environment_files\n # deploy_services\n response\n end",
"def deploy\n unless serverside_version\n # only set serverside version if it's not set, to imitate the api\n # behavior of choosing its own serverside version if one is not\n # sent\n update :serverside_version => AWSM_SERVERSIDE_VERSION\n end\n finished!(\n :successful => true,\n :output => 'Deployment triggered by the API'\n )\n end",
"def action_deploy\n set_state\n notifying_block do\n write_config\n run_syncdb\n run_migrate\n run_collectstatic\n end\n end",
"def run(params={})\n config_name = params.has_key?(:config_name) ? params[:config_name].to_sym : :default\n\n # Validate config\n error 'No deploy configuration found' if @site.config[:deploy].nil?\n error \"No deploy configuration found for #{config_name}\" if @site.config[:deploy][config_name].nil?\n \n src_branch = @site.config[:deploy][config_name][:src_branch]\n dst_branch = @site.config[:deploy][config_name][:dst_branch]\n dst_remote = @site.config[:deploy][config_name][:dst_remote]\n \n error 'No source branch found in deployment configuration' if src_branch.nil?\n error 'No destination branch found in deployment configuration' if dst_branch.nil?\n error 'No destination remote found in deployment configuration' if dst_remote.nil?\n \n git = ::Git::Base.open('.')\n \n # Compile the site from scratch\n Nanoc::Tasks::Clean.new(@site).run\n \n # Check out the source branch\n puts \"Checking out #{src_branch}.\"\n git.checkout(src_branch)\n \n # Compile the site from scratch\n puts \"Compiling site.\"\n @site.compiler.run\n \n # Check out the destination branch\n puts \"Checking out destination branch.\"\n git.checkout(dst_branch)\n \n # Copy output files recursively into the current directory\n puts \"Copying files.\"\n FileUtils.cp_r(@site.config[:output_dir].chomp('/') + '/.', '.')\n \n # Automatically add and commit changes\n puts \"Committing changes.\"\n git.add\n git.commit(\"updated #{Time.now.to_s}\", :add_all => true)\n \n # Push changes to the destination repo/branch\n puts \"Pushing to #{dst_remote} #{dst_branch}.\"\n git.push(dst_remote, dst_branch)\n \n # Switch back to the source branch\n puts \"Checking out #{src_branch}.\"\n git.checkout(src_branch)\n end",
"def run\n case action\n when 'new'\n require_relative('templater')\n Templater.new(File.expand_path(directory, Dir.pwd), settings).run!\n when 'console'\n require_relative('console')\n Wukong::Deploy::Console.new.run!\n end\n end",
"def prepare_deploy\n `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy:setup -S phase=node_prepare HOSTS=#{self.hostname}`\n `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy -S phase=node_prepare HOSTS=#{self.hostname}`\n end",
"def deploy\n Tipsy::Runners::Deployer.new\n end",
"def deploy\n cmd = \"deploy #{@resource[:source]} --name=#{@resource[:name]}#{runtime_name_param_with_space_or_empty_string}\"\n if @resource[:runasdomain]\n cmd = append_groups_to_cmd(cmd, @resource[:servergroups])\n end\n cmd = \"#{cmd} --force\" if force_deploy?\n display_lines 100\n bring_up 'Deployment', cmd\n @resource[:name]\n end",
"def deploy\n what = ARGV.shift\n\n case what\n when 'packages'\n deploy_packages\n else\n ARGV.unshift what\n original_deploy\n end\n end",
"def deploy!\n write_previous_revision\n update_repository\n write_revision\n end",
"def deploy\n\t\t\tdeployPlanString = @repo.get_file_content('.deploy_plan.xml',@params['commit']||@params['branch'])\n\t\t\txmlRoot = XmlUtils.get_xml_root(deployPlanString)\n\t\t\t# select plan\n\t\t\tplanNode = XmlUtils.single_node(xmlRoot,'plan')\n\t\t\t# for each deploy\n\t\t\tdeployNode = XmlUtils.single_node(planNode,'deploy')\n\t\t\t# create client for kind/method\n\t\t\t@site_client = DesignShell::SiteClient.new({\n\t\t\t\t:site_url => @params['site_url'],\n\t\t\t\t:site_username => @params['site_username'],\n\t\t\t\t:site_password => @params['site_password'],\n\t\t\t})\n\t\t\tds = @site_client.deploy_status\n\t\t\tsite_repo_url = ds && ds['repo_url'].to_nil\n\t\t\tsite_branch = ds && ds['branch'].to_nil\n\t\t\tsite_commit = ds && ds['commit'].to_nil\n\t\t\trepo_url = @repo.url\n\t\t\t# @todo must limit uploads to build folder\n\t\t\tfromPath = MiscUtils.ensure_slashes(XmlUtils.peek_node_value(deployNode,'fromPath','/'),false,true) # eg. /build/bigcommerce effectively selects a subfolder that should be debased\n\t\t\ttoPath = MiscUtils.ensure_slashes(XmlUtils.peek_node_value(deployNode,'toPath','/'),false,true) # eg. / effectively the new base for these files\n\t\t\tif site_repo_url && site_repo_url==repo_url && site_branch && site_commit\n\t\t\t\t# incremental\n\t\t\t\tchanges = @repo.changesBetweenCommits(site_commit,@repo.head.to_s)\n\t\t\t\tuploads,deletes = convertChangesToUploadsDeletes(changes)\n\t\t\t\tuploads.delete_if { |fp| !fp.begins_with?(fromPath) }\n\t\t\t\tdeletes.delete_if { |fp| !fp.begins_with?(fromPath) }\n\t\t\t\t@site_client.delete_files(deletes,fromPath,toPath)\n\t\t\t\t@site_client.upload_files(@repo.path,uploads,fromPath,toPath)\n\t\t\t\t@site_client.deploy_status = {\n\t\t\t\t\t:repo_url => @repo.url,\n\t\t\t\t\t:branch => @repo.branch,\n\t\t\t\t\t:commit => @repo.head.to_s,\n\t\t\t\t :fromPath => fromPath,\n\t\t\t\t :toPath => toPath\n\t\t\t\t}\n\t\t\telse\n\t\t\t\t# complete\n\t\t\t\t# for now, just deploy all files in wd, creating folders as necessary\n\t\t\t\t# later, delete remote files not in wd except for eg. .deploy-status.xml and perhaps upload folders\n\t\t\t\tuploads = MiscUtils.recursive_file_list(@repo.path,false)\n\t\t\t\tuploads.delete_if do |fp|\n\t\t\t\t\t!fp.begins_with?(fromPath) || fp.begins_with?('.git/')\n\t\t\t\tend\n\t\t\t\t@site_client.upload_files(@repo.path,uploads,fromPath,toPath)\n\t\t\t\t@site_client.deploy_status = {\n\t\t\t\t\t:repo_url => @repo.url,\n\t\t\t\t\t:branch => @repo.branch,\n\t\t\t\t\t:commit => @repo.head.to_s,\n\t\t\t\t\t:fromPath => fromPath,\n\t\t :toPath => toPath\n\t\t\t\t}\n\t\t\tend\n\t\tend",
"def deploy\n\n $active_deploy = true\n bucket = JSON.parse($deploy_bucket.last.to_json)\n unless bucket.nil?\n puts \"Deploying code for: #{bucket.inspect}\"\n system(\"./deploy.sh #{bucket['git_account']} #{bucket['launch_branch_name']} #{bucket['git_appname']} #{bucket['heroku_appname']} #{bucket['folder_name']}\")\n end\n $deploy_bucket.pop\n puts \"Now making active_deploy as false\"\n $active_deploy = false\n check_build bucket\nend",
"def default_deploy\n setup\n update_repo_tag\n push_repo\n maintenance_mode do\n run_migrations\n app_restart\n end\n warm_instance\n teardown\n end",
"def deploy\n\t# This task is typiclly run after the site is updated but before the server is restarted.\nend",
"def deploy\n\t# This task is typiclly run after the site is updated but before the server is restarted.\nend",
"def deploy repository, branch\n\n super do\n section \"Installing dependencies with #{`bundle -v`.chomp}...\" do\n install_dependencies\n end\n\n section \"Precompiling assets...\" do\n precompile_assets\n end if precompile_assets?\n end\n\n end",
"def deploy?; run_options[:deploy]; end",
"def release\n diagnostic_file = File.join JONAS_ROOT, \"diagnostics\", 'launch_jonas_diags.rb'\n diagnostics_cmd = \"ruby #{diagnostic_file}\"\n app_war_file = File.join JONAS_BASE, 'deploy' , 'app.war'\n if_jonas_base_exists_string = \"(if test ! -d #{app_war_file} ; then\"\n java_home_string = \"JAVA_HOME=#{@java_home}\"\n java_opts_string = \"JAVA_OPTS=\\\"#{ContainerUtils.to_java_opts_s(@java_opts)}\\\"\"\n export_base_vars_string = 'export JAVA_HOME JAVA_OPTS'\n export_deployme_vars_string = 'export JONAS_ROOT JONAS_BASE'\n deployme_var_string = \"JONAS_ROOT=#{JONAS_ROOT} JONAS_BASE=#{JONAS_BASE}\"\n deployme_root = File.join JONAS_ROOT, 'deployme'\n topology_xml_erb_file = File.join deployme_root, 'topology.xml.erb'\n topology_xml_file = File.join deployme_root, 'topology.xml'\n deployme_jar_file = File.join deployme_root, 'deployme.jar'\n topology_erb_cmd_string = \"erb #{topology_xml_erb_file} > #{topology_xml_file}\"\n deployme_cmd_string = \"$JAVA_HOME/bin/java -jar #{deployme_jar_file} -topologyFile=#{topology_xml_file} -domainName=singleDomain -serverName=singleServerName\"\n else_skip_string = 'else echo \"skipping jonas_base config as already present\"; fi)'\n setenv_cmd_string = File.join JONAS_BASE, 'setenv'\n copyapp_cmd = \"mkdir -p #{app_war_file} && cp -r --dereference * #{app_war_file}/\"\n start_script_string = \"source #{setenv_cmd_string} && jonas start -fg\"\n\n \"(#{diagnostics_cmd} & ); #{java_home_string} #{java_opts_string} && #{export_base_vars_string} && #{if_jonas_base_exists_string} #{deployme_var_string} && #{export_deployme_vars_string} && #{topology_erb_cmd_string} && #{deployme_cmd_string} && #{copyapp_cmd}; #{else_skip_string} && #{start_script_string}\"\n end",
"def deploy(options={})\n buffer = \"Starting application #{application_name}\\n\"\n\n if options[:out]\n options[:out].puts(buffer)\n end\n\n buffer << start_gear(secondary_only: true,\n user_initiated: true,\n hot_deploy: options[:hot_deploy],\n out: options[:out],\n err: options[:err])\n\n @state.value = ::OpenShift::Runtime::State::DEPLOYING\n\n web_proxy_cart = @cartridge_model.web_proxy\n if web_proxy_cart\n buffer << @cartridge_model.do_control('deploy',\n web_proxy_cart,\n pre_action_hooks_enabled: false,\n prefix_action_hooks: false,\n out: options[:out],\n err: options[:err])\n end\n\n buffer << @cartridge_model.do_control('deploy',\n @cartridge_model.primary_cartridge,\n pre_action_hooks_enabled: false,\n prefix_action_hooks: false,\n out: options[:out],\n err: options[:err])\n\n buffer << start_gear(primary_only: true,\n user_initiated: true,\n hot_deploy: options[:hot_deploy],\n out: options[:out],\n err: options[:err])\n\n buffer << @cartridge_model.do_control('post-deploy',\n @cartridge_model.primary_cartridge,\n pre_action_hooks_enabled: false,\n prefix_action_hooks: false,\n out: options[:out],\n err: options[:err])\n\n buffer\n end",
"def register_as_deployed\n AddCommand.exec \"#{self.name}:#{self.root_path}\", 'servers' => [@shell]\n end",
"def create\n deploy\n end",
"def run\n unless !@valid_name || File.exists?(@project_name) || File.directory?(@project_name)\n $stdout.puts \"Creating goliath application under the directory #{@project_name}\"\n FileUtils.mkdir @project_name\n \n create_base_dirs\n copy_files_to_target\n setup_api_module\n copy_files_to_dir 'application.rb','config'\n copy_files_to_dir 'database.yml','config'\n $stdout.puts \"\\e[1;32m \\trun\\e[0m\\tbundle install\"\n Dir.chdir(\"#{@project_name}\")\n system(\"bundle install\")\n else \n unless !@valid_name\n $stdout.puts \"\\e[1;31mError:\\e[0m The directory #{@project_name} already exists, aborting. Maybe move it out of the way before continuing.\"\n end\n end\n end",
"def deploy_in_background! \n unless RAILS_ENV == 'test' \n RAILS_DEFAULT_LOGGER.info \"Calling other ruby process in the background in order to deploy deployment #{self.id} (stage #{self.stage.id}/#{self.stage.name})\"\n system(\"sh -c \\\"cd #{RAILS_ROOT} && ruby script/runner -e #{RAILS_ENV} ' deployment = Deployment.find(#{self.id}); deployment.prompt_config = #{self.prompt_config.inspect.gsub('\"', '\\\"')} ; Webistrano::Deployer.new(deployment).invoke_task! ' >> #{RAILS_ROOT}/log/#{RAILS_ENV}.log 2>&1\\\" &\")\n end\n end",
"def deploy_local(appdir, appname, params={})\n @vespa.deploy_local(appdir, appname, @vespa.nodeproxies[hostlist.first], selfdir, params)\n end",
"def run_predeploy\n super do\n update_task_revision\n\n begin\n @deploy_config.predeploy_commands.each { |command| run_command(command) }\n ensure\n EcsManager.deregister_last_n_tasks_definitions(family, 1)\n end\n end\n end",
"def execute!\n config = instantiate_configuration\n config.logger.level = options[:verbose]\n config.load 'deploy'\n\n status = catch(:abort_called_by_capistrano){\n set_webistrano_logger(config)\n \n set_up_config(config)\n \n exchange_real_revision(config) unless (config.fetch(:scm).to_s == 'git') # git cannot do a local query by default\n save_revision(config)\n save_pid\n \n config.trigger(:load)\n execute_requested_actions(config)\n config.trigger(:exit)\n }\n \n if status == :capistrano_abort\n false\n else\n config\n end\n rescue Exception => error\n handle_error(error) \n return false\n end",
"def deploy_in_background!\n notify_hipchat_on_execute\n unless Rails.env.test?\n Rails.logger.info \"Calling other ruby process in the background in order to deploy deployment #{self.id} (stage #{self.stage.id}/#{self.stage.name})\"\n\n system <<\"EOS\"\ncd #{Rails.root} && rails runner -e #{Rails.env} 'deployment = Deployment.find(#{self.id}); deployment.prompt_config = #{self.prompt_config.inspect.gsub('\"', '\\\"')} ; Webistrano::Deployer.new(deployment).invoke_task! ' >> #{Rails.root}/log/#{Rails.env}.log 2>&1 &\nEOS\n end\n end",
"def filesync_deploy\n @logger.debug('Pem::filesync_deploy') { 'starting filesync deploy' }\n\n ssl_options = {\n 'client_cert' => OpenSSL::X509::Certificate.new(File.read(@conf['filesync_cert'])),\n 'client_key' => OpenSSL::PKey::RSA.new(File.read(@conf['filesync_cert_key'])),\n 'ca_file' => @conf['filesync_ca_cert'],\n }\n\n conn = Faraday.new(url: \"https://#{@conf['master']}:8140\", ssl: ssl_options) do |faraday|\n faraday.request :json\n faraday.options[:timeout] = 300\n faraday.adapter Faraday.default_adapter\n end\n\n @logger.debug('Pem::filesync_deploy') { 'Hitting filesync commit endpoint...' }\n conn.post '/file-sync/v1/commit', 'commit-all' => true\n @logger.debug('Pem::filesync_deploy') { 'Done.' }\n\n @logger.debug('Pem::filesync_deploy') { 'Hitting filesync force-sync endpoint...' }\n conn.post '/file-sync/v1/force-sync'\n @logger.debug('Pem::filesync_deploy') { 'Done.' }\n\n @logger.debug('Pem::filesync_deploy') { 'Hitting puppet-admin-api env endpoint...' }\n conn.delete '/puppet-admin-api/v1/environment-cache'\n @logger.debug('Pem::filesync_deploy') { 'Done.' }\n\n @logger.debug('Pem::filesync_deploy') { 'completed filesync deploy' }\n end",
"def deploy(&block)\n in_directory do\n self.setup!\n self.push_with_retry!\n block.call(self, platform_api, output) if block_given?\n end\n ensure\n self.teardown!\n end",
"def compile\n download_jonas\n download_deployme\n remove_jcl_over_slf\n puts 'Compile completed, release cmd to be run:'\n puts release\n end",
"def deploy(package_path, opts={}, &block)\n end",
"def deploy\n params = {\n :migrate => migrate,\n :ref => ref,\n }\n params[:serverside_version] = serverside_version if serverside_version\n params[:migrate_command] = migrate_command if migrate\n update_with_response api.post(collection_uri + \"/deploy\", 'deployment' => params)\n end",
"def deploy\n system %Q[ssh -lroot \"#{server}\" <<'EOF'\n \tcat >\"#{remote_script_name}\" <<'EOS'\n#{generate}EOS\nchmod +x \"#{remote_script_name}\"\nsource \"#{remote_script_name}\"\nEOF\n ]\n end",
"def deploy_in_background! \n unless Rails.env.test?\n Rails.logger.info \"Calling other ruby process in the background in order to deploy deployment #{self.id} (stage #{self.stage.id}/#{self.stage.name})\"\n\n system(\"sh -c \\\"cd #{Rails.root} && rails runner -e #{Rails.env} ' deployment = Deployment.find(#{self.id}); deployment.prompt_config = #{self.prompt_config.inspect.gsub('\"', '\\\"')} ; Webistrano::Deployer.new(deployment).invoke_task! ' >> #{Rails.root}/log/#{Rails.env}.log 2>&1\\\" &\")\n end\n end",
"def deploySource\n verifyOS\n timeDate = Time.new\n vConfig(CONFIG['configWebsite'])\n read_json(CONFIG['configWebsite'])\n branchSource = @parse_json_config['deploy']['branch']['source']\n msgCommit = @parse_json_config['deploy']['github']['config']['commit']\n add_repo_git(\".\")\n add_remoteurl(\".\")\n pull_execute(branchSource, \".\")\n git_checkout(branchSource, \".\")\n system_commands(\"echo Deploy source files. Wait ...\")\n system_commands(\"git add .\")\n system_commands(\"git commit -m \\\"#{msgCommit} - #{timeDate.inspect}\\\"\")\n system_commands(\"git push origin -u #{branchSource}\")\n end",
"def perform\n validate_system_config\n\n deployment_name = \"#{system_config.system_name}-core\"\n\n manifest = base_manifest(\n deployment_name,\n bosh_config.target_uuid,\n system_config.bosh_provider,\n system_config.system_name,\n system_config.release_name,\n system_config.release_version,\n system_config.stemcell_name,\n system_config.stemcell_version,\n cloud_properties_for_server_flavor(system_config.core_server_flavor),\n system_config.core_ip,\n system_config.root_dns,\n system_config.admin_emails,\n system_config.common_password,\n system_config.common_persistent_disk,\n system_config.security_group\n )\n\n dea_config.build_into_manifest(manifest)\n system_config.services.each do |service_config|\n service_config.build_into_manifest(manifest)\n end\n\n chdir system_config.system_dir do\n mkdir_p(\"deployments\")\n File.open(\"deployments/#{system_config.system_name}-core.yml\", \"w\") do |file|\n file << manifest.to_yaml\n end\n end\n end",
"def do_deploy()\n require 'digest/md5'\n require 'aws-sdk'\n require 'progressbar'\n require 'simple-cloudfront-invalidator'\n require 'yaml'\n\n # Validation check for environment variables\n if (!ENV['AWS_S3_BUCKET'] ||\n !ENV['AWS_ACCESS_KEY_ID'] ||\n !ENV['AWS_SECRET_ACCESS_KEY'] ||\n !ENV['AWS_CLOUDFRONT_DIST_ID'] ||\n !ENV['AWS_HOST_NAME'] )\n puts(\"The below required environment variable(s) have not been defined.\\n\"\\\n \"Without them, the Deploy process cannot complete.\\n\"\\\n \"Please verify that they have been correctly defined.\")\n puts(\" * AWS_S3_BUCKET\") if (!ENV['AWS_S3_BUCKET'])\n puts(\" * AWS_ACCESS_KEY_ID\") if (!ENV['AWS_ACCESS_KEY_ID'])\n puts(\" * AWS_SECRET_ACCESS_KEY\") if (!ENV['AWS_SECRET_ACCESS_KEY'])\n puts(\" * AWS_CLOUDFRONT_DIST_ID\") if (!ENV['AWS_CLOUDFRONT_DIST_ID'])\n puts(\" * AWS_HOST_NAME\") if (!ENV['AWS_HOST_NAME'])\n exit()\n end\n\n puts(\"========================================\")\n puts(\"Beginning Deploy Process...\")\n\n # Capture Hugo's config.yaml while we're in the same directory\n config_file = YAML.load_file('config.yaml')\n\n # Make sure we actually loaded a file, and didn't just set `config_file` to\n # the string \"config.yaml\".\n if (config_file == \"config.yaml\")\n Kernel.abort(\"ERROR: Could not find 'config.yaml'. Are you running Rake \"\\\n \"from the correct directory?\")\n end\n\n # Move into the Hugo destination directory, so file names are only prefixed\n # with \"./\"\n Dir.chdir(File.join(Dir.pwd, \"#{$hugo_dest}\"))\n\n # Generate a list of every file in $hugo_dest, and `map` them into the form,\n # [[\"«file_name»\", \"«md5sum»\"], ... ]\n puts(\" Aggregating Local Hash List...\")\n local_file_list = Dir[\"./**/*\"]\n .select { |f| File.file?(f) }\n .sort_by { |f| f }\n .map { |f|\n # The file names have a leading `./`. Strip those.\n [f[2..-1], Digest::MD5.file(f).hexdigest] }\n\n\n # Open up a connection to our S3 target bucket\n puts(\" Opening S3 Connection...\")\n aws_bucket = Aws::S3::Bucket.new(ENV['AWS_S3_BUCKET'], {\n :region => \"us-east-1\",\n :access_key_id => ENV['AWS_ACCESS_KEY_ID'],\n :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'],\n })\n\n # Fetch all objects from the remote, and `map` them into the form,\n # [[\"«file_name»\", \"«md5sum»\"], ... ]\n puts(\" Fetching Remote Object List (this may take up to ~30 seconds)...\")\n aws_file_list = aws_bucket\n .objects()\n .sort_by { |objs| objs.key }\n .map { |objs|\n # the etag (which is the md5sum) is wrapped in double-quotes. Strip those\n # by 'translating' them into empty strings.\n [objs.key, objs.etag.tr('\"','')] }\n\n\n # Now that we have the two lists, we need to compare them and generate the\n # list of files we need to upload, and the list of files we need to delete.\n # To do this, we're going to use some brute force.\n puts(\" Comparing Object Hashes...\")\n new_list = []\n updated_list = []\n delete_list = []\n lcl_i = 0\n aws_i = 0\n lcl_len = local_file_list.length\n aws_len = aws_file_list.length\n progress = ProgressBar.new(\" Hash check\", lcl_len)\n while true\n # Check if we've reached the end of either list and should break\n break if (lcl_i == lcl_len || aws_i == aws_len)\n lcl_file_name = local_file_list[lcl_i][0]\n aws_file_name = aws_file_list[aws_i][0]\n\n # Compare the file/object names\n case lcl_file_name <=> aws_file_name\n when 0 # File names are identical\n # Compare md5sums. If they don't match, add the file to the updated list.\n if (local_file_list[lcl_i][1] != aws_file_list[aws_i][1])\n updated_list.push(lcl_file_name)\n end\n # In either case, increment both index variables\n lcl_i += 1; progress.inc\n aws_i += 1\n when -1 # Local file name sorts first...\n # The local file doesn't exist on AWS. Add it to the new list.\n new_list.push(lcl_file_name)\n # And only increment the local index variable.\n lcl_i += 1; progress.inc\n when 1 # AWS object name sorts first...\n # The AWS object doesn't (or no longer) exist in the locally built\n # artifacts. Schedule it for deletion.\n delete_list.push(aws_file_name)\n # And only increment the aws index variable.\n aws_i += 1\n end\n end\n\n # If we're not at the end of the local file list, we need to add any new files\n # to the new list.\n while (lcl_i < lcl_len)\n new_list.push(local_file_list[lcl_i][0])\n lcl_i += 1; progress.inc\n end\n\n # If we're not at the end of the aws object list, we need to add those file to\n # the delete list.\n while (aws_i < aws_len)\n delete_list.push(aws_file_list[aws_i][0])\n aws_i += 1\n end\n progress.finish\n\n upload_list = updated_list + new_list\n\n puts(\" Hash Check complete\")\n puts(\" #{new_list.length} new files, and #{updated_list.length} updated..\")\n puts(\" #{upload_list.length} files need to be uploaded to the remote\")\n puts(\" #{delete_list.length} files need to be deleted from the remote\")\n current_time = Time.now.getutc.to_s.gsub(\" \",\"_\")\n File.open(\"new_file_list-#{current_time}.txt\", \"w+\") do |f|\n f.puts(new_list)\n end\n File.open(\"updated_file_list-#{current_time}.txt\", \"w+\") do |f|\n f.puts(upload_list)\n end\n File.open(\"deleted_list-#{current_time}.txt\", \"w+\") do |f|\n f.puts(delete_list)\n end\n\n\n # Upload the files in the upload updated and new lists, and delete the files\n # in the delete list.\n if (upload_list.length > 0)\n puts(\" Uploading files...\")\n progress = ProgressBar.new(\" Uploads\", upload_list.length)\n upload_list.each { |obj_path|\n #TODO: Generate a log of the uploaded files?\n #TODO: Error checking.\n #TODO: Stop publishing read/write.\n aws_bucket.put_object({\n acl: \"public-read-write\",\n key: obj_path,\n body: File.open(obj_path)\n })\n progress.inc\n }\n progress.finish\n else\n puts(\" No files to upload...\")\n end\n\n if (delete_list.length > 0)\n delete_list.each_slice(1000).with_index do |slice, index|\n index_from = index * 1000\n index_to = ((index+1)*1000) < delete_list.length ? ((index+1)*1000) : delete_list.length\n puts(\" Requesting Batch Delete for objects #{index_from}-#{index_to}...\")\n # Generate a Aws::S3::Types::Delete hash object.\n delete_hash = {\n delete: {\n objects: slice.map{ |f| { key: f } },\n quiet: false\n }\n }\n #TODO: Generate a log of the deleted files?\n begin\n response = aws_bucket.delete_objects(delete_hash)\n rescue Exception => e\n require 'pp'\n Kernel.abort(\"ERRROR: Batch Deletion returned with errors.\\n\"\\\n \" Delete Hash Object:\\n\"\\\n \"#{pp(delete_hash)}\\n\"\\\n \" Error message:\\n\"\\\n \"#{e.message}\")\n end\n if (response.errors.length > 0)\n require 'pp'\n Kernel.abort(\"ERRROR: Batch Deletion returned with errors\\n\"\\\n \" Delete Hash Object:\\n\"\\\n \"#{pp(delete_hash)}\\n\"\\\n \" Response Object:\\n\"\\\n \"#{pp(response)}\")\n end\n end\n else\n puts(\" No files to delete...\")\n end\n\n # Fetch and rewrite the S3 Routing Rules to make sure the 'latest' of every\n # project correctly re-route.\n puts(\" Configuring S3 Bucket Website redirect rules...\")\n\n # Open an S3 connection to the Bucket Website metadata\n aws_bucket_website = Aws::S3::BucketWebsite.new(ENV['AWS_S3_BUCKET'], {\n :region => \"us-east-1\",\n :access_key_id => ENV['AWS_ACCESS_KEY_ID'],\n :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'],\n })\n\n # Build the routing rules based on the config.yaml's 'project_descripts'. One\n # routing rule per project.\n routing_rules = []\n config_file['params']['project_descriptions'].each do |project, description|\n path = description['path']\n archived_path = description['archived_path']\n ver = description['latest']\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{archived_path}/latest/\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{archived_path}/latest\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{path}/latest/\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{path}/latest\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n end\n #TODO: We need to implement some way of adding arbitrary routing rules. Maybe\n # add a section in config.yaml that's just a JSON string that we parse?\n riak_path = config_file['params']['project_descriptions']['riak_kv']['path']\n riak_ver = config_file['params']['project_descriptions']['riak_kv']['latest']\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"riakee/latest/\" },\n :redirect => { :replace_key_prefix_with => \"#{riak_path}/#{riak_ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"riakee/latest\" },\n :redirect => { :replace_key_prefix_with => \"#{riak_path}/#{riak_ver}\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"riakts/\" },\n :redirect => { :replace_key_prefix_with => \"riak/ts/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n\n new_website_configuration = {\n :error_document => {:key => \"404.html\"},\n :index_document => aws_bucket_website.index_document.to_hash,\n :routing_rules => routing_rules\n }\n\n aws_bucket_website.put({ website_configuration: new_website_configuration })\n\n # Invalidate any files that were deleted or modified.\n cf_client = SimpleCloudfrontInvalidator::CloudfrontClient.new(\n ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'],\n ENV['AWS_CLOUDFRONT_DIST_ID'])\n invalidation_list = updated_list + delete_list\n if (invalidation_list.length == 0)\n puts(\" No files to invalidate...\")\n elsif (invalidation_list.length < 500)\n # The invalidation list is sufficiently short that we can invalidate each\n # individual file\n invalidation_list.each_slice(100).with_index do |slice, index|\n index_from = (index*100)\n index_to = ((index+1)*100) < delete_list.length ? ((index+1)*100) : delete_list.length\n puts(\" Sending Invalidation Request for objects #{index_from}-#{index_to}...\")\n cf_report = cf_client.invalidate(slice)\n end\n else\n # The invalidation list is large enough that we should skip getting charged\n # and invalidate the entire site.\n puts(\" Sending Invalidation Request for the entire site (\\\"/*\\\")...\")\n cf_report = cf_client.invalidate(['/*'])\n end\n\n puts(\"\")\n puts(\"Deploy Process Complete!\")\n puts(\"========================================\")\nend",
"def deploy(id, host, remote_dfile, not_used)\n local_dfile = get_local_deployment_file(remote_dfile)\n\n if !local_dfile || File.zero?(local_dfile)\n send_message(ACTION[:deploy],RESULT[:failure],id,\n \"Can not open deployment file #{local_dfile}\")\n return\n end\n \n local_action(\"#{@actions_path}/deploy #{host} #{local_dfile}\",id,:deploy)\n end",
"def deploy(id, host, remote_dfile, not_used)\n error = \"Action not implemented by driver #{self.class}\"\n send_message(ACTION[:deploy],RESULT[:failure],id,error)\n end",
"def remote_deploy(options={})\n @cartridge_model.do_control('update-configuration',\n @cartridge_model.primary_cartridge,\n pre_action_hooks_enabled: false,\n post_action_hooks_enabled: false,\n out: options[:out],\n err: options[:err])\n\n deploy(options)\n\n if options[:init]\n primary_cart_env_dir = PathUtils.join(@container_dir, @cartridge_model.primary_cartridge.directory, 'env')\n primary_cart_env = ::OpenShift::Runtime::Utils::Environ.load(primary_cart_env_dir)\n ident = primary_cart_env.keys.grep(/^OPENSHIFT_.*_IDENT/)\n _, _, version, _ = Runtime::Manifest.parse_ident(primary_cart_env[ident.first])\n\n @cartridge_model.post_install(@cartridge_model.primary_cartridge,\n version,\n out: options[:out],\n err: options[:err])\n\n end\n end",
"def post_build\n puts '### gulp package ###'\n # tar up the files.\n puts `gulp package 2>&1`\n puts '### gulp package done ###'\n deploy_maven\nend",
"def start(*args)\n logger.info('Starting load generation and monitoring on targets...')\n redeploy = (args.empty? ? false : true)\n current_project.start(redeploy)\n\n show_load_agents\n show_target_hosts\n end",
"def create_deploy\n @@tpl = CapistranoDeployGenerator.source_root\n empty_directory \"config/deploy\"\n\n say <<-EOF\n\nconfig/deploy.rb generator\n\nThis menu will help you creating deployment configuration file\ndeploy.rb for Capistrano. It is safe to acceppt defulat values for\nmost or all questions. Just hit Enter if default is provided.\n\nAll values can be changed later in the file itself or you can re-run\ngenerator again.\n\nEOF\n template \"deploy.rb.erb\", \"config/deploy.rb\"\n @stages.each do |stage|\n template \"staging.rb.erb\", \"config/deploy/#{stage}.rb\" \n end\n say \"Please edit manually configuration of the multi-staging files:\"\n @stages.map { |x| say \"./confg/deploy/#{x}.rb\\n\"}\n end",
"def run!\n project.mode = :release\n\n # Validate paths\n validate_paths!\n\n # Extract mockup\n copy_source_path_to_build_path!\n\n validate_stack!\n\n # Run stack\n run_stack!\n\n # Cleanup\n cleanup! if config[:cleanup_build]\n ensure\n project.mode = nil\n end",
"def action_before_deploy\n install_packages\n end",
"def compile\n system \"rm -rf #{new_relic_home}\"\n system \"mkdir -p #{new_relic_home}\"\n system \"mkdir -p #{File.join new_relic_home, 'logs'}\"\n\n JavaBuildpack::Util.download(@version, @uri, 'New Relic Agent', jar_name(@version), new_relic_home)\n copy_resources new_relic_home\n end",
"def deploy!\n puts \"Adding and committing compiled output for deployment..\"\n puts %x[git add .]\n puts %x[git commit -a -m \"temporary commit for deployment\"]\n puts 'Deploying to Heroku..'\n puts %x[git push heroku HEAD:master --force]\nend",
"def deploy!\n puts \"Adding and committing compiled output for deployment..\"\n puts %x[git add .]\n puts %x[git commit -a -m \"temporary commit for deployment\"]\n puts 'Deploying to Heroku..'\n puts %x[git push heroku HEAD:master --force]\nend",
"def deploy!\n puts \"Adding and committing compiled output for deployment..\"\n puts %x[git add .]\n puts %x[git commit -a -m \"temporary commit for deployment\"]\n puts 'Deploying to Github pages..'\n puts %x[git push origin HEAD:gh-pages --force]\nend",
"def run_all\n deploy_code\n run_test\n end",
"def add_post_deploy_resources\n if new_resource.precompile_assets\n app_local = app\n username = user_username\n ruby_block 'precompile assests' do\n block do\n require 'bundler'\n bundle_precompile_command = \"sudo su - #{username} -c 'cd #{app_local.release_path} \"\\\n \"&& source ./.env && #{app_local.bundle_binary} exec rake #{new_resource.precompile_command}'\"\n\n Bundler.clean_system(bundle_precompile_command)\n raise('Bundle pre-compile failed') unless $CHILD_STATUS.exitstatus.zero?\n end\n action :nothing\n subscribes :run, \"deploy_revision[#{new_resource.name}]\", :immediate\n end\n end\n\n super\n end",
"def deploy\n\t# This task is typiclly run after the site is updated but before the server is restarted.\n\tcall 'migrate'\nend",
"def deploy_app(app, deploy_params = {})\n deploy_generated(app.services_xml, app.sd_files,\n deploy_params.merge(app.deploy_params), app.hosts_xml, nil, app.validation_overrides_xml)\n end",
"def build\n Bridgetown.logger.adjust_verbosity(options)\n\n unless caller_locations.find do |loc|\n loc.to_s.include?(\"bridgetown-core/commands/start.rb\")\n end\n self.class.print_startup_message\n end\n\n # @type [Bridgetown::Configuration]\n config_options = configuration_with_overrides(\n options, Bridgetown::Current.preloaded_configuration\n )\n\n config_options.run_initializers! context: :static\n\n config_options[\"serving\"] = false unless config_options[\"serving\"]\n\n if !Bridgetown.env.production? &&\n !config_options[:skip_frontend] && config_options[\"using_puma\"]\n if Bridgetown::Utils.frontend_bundler_type(config_options[:root_dir]) == :esbuild\n Bridgetown::Utils.update_esbuild_autogenerated_config config_options\n end\n require \"rake\"\n Rake.with_application do |rake|\n rake.load_rakefile\n rake[\"frontend:watcher\"].invoke(true)\n end\n end\n\n @site = Bridgetown::Site.new(config_options)\n\n if config_options.fetch(\"skip_initial_build\", false)\n Bridgetown.logger.warn \"Build Warning:\", \"Skipping the initial build. \" \\\n \"This may result in an out-of-date site.\"\n else\n build_site(config_options)\n end\n\n if config_options.fetch(\"detach\", false)\n Bridgetown.logger.info \"Auto-regeneration:\",\n \"disabled when running server detached.\"\n elsif config_options.fetch(\"watch\", false)\n watch_site(config_options)\n else\n Bridgetown.logger.info \"Auto-regeneration:\", \"disabled. Use --watch to enable.\"\n end\n end",
"def run\n ready_nodes = each_ready_task.to_a.join ', '\n info \"Starting the deployment process. Starting tasks: #{ready_nodes}\"\n hook 'internal_pre_run'\n hook 'pre_run'\n topology_sort\n result = loop do\n if all_nodes_are_successful?\n status = 'All nodes are deployed successfully. '\\\n 'Stopping the deployment process!'\n result = {\n :success => true,\n :status => status,\n }\n break result\n end\n gracefully_stop! \"failed_critical_nodes: #{failed_critical_nodes.inspect}\" if has_failed_critical_nodes?\n\n if all_nodes_are_finished?\n status = \"All nodes are finished. Failed tasks: \"\\\n \"#{failed_tasks.join ', '} Stopping the \"\\\n \"deployment process!\"\n result = if has_failed_critical_nodes?\n {\n :success => false,\n :status => status,\n :failed_nodes => failed_nodes,\n :skipped_nodes => skipped_nodes,\n :failed_tasks => failed_tasks\n }\n else\n {\n :success => true,\n :status => status,\n :failed_nodes => failed_nodes,\n :skipped_nodes => skipped_nodes,\n :failed_tasks => failed_tasks\n }\n end\n break result\n end\n # run loop over all nodes\n process_all_nodes\n end\n info result[:status]\n hook 'post_run', result\n result\n end",
"def exec\r\n if valid?\r\n _result = configure\r\n _result &&= compile\r\n _result &&= install\r\n end\r\n end",
"def pre_perform!\n return unless perform_hooks?\n unless hooks.pre_hooks.any?\n GitPusshuTen::Log.message \"No pre deploy hooks to perform.\"\n return\n end\n \n ##\n # Connect to the remote environment and perform the pre deploy hooks\n hooks.render_commands(hooks.pre_hooks).each do |name, commands|\n adjusted_name = name.sub(/^\\d+\\)\\s/, '')\n \n GitPusshuTen::Log.message(\"Performing pre deploy hook: #{y(adjusted_name)}\")\n standard environment.execute_as_user(\"cd '#{e.app_dir}'; #{commands}\")\n end\n end",
"def deploy(id, host, xml_text, lcm_state, deploy_id)\n # Restore if we need to\n if lcm_state != \"BOOT\" && lcm_state != \"BOOT_FAILURE\"\n restore(deploy_id)\n return deploy_id\n end\n\n # Otherwise deploy the VM\n\n begin\n ec2_info = get_deployment_info(host, xml_text)\n rescue Exception => e\n raise e\n end\n\n load_default_template_values\n\n if !ec2_value(ec2_info, 'AMI')\n raise \"Cannot find AMI in deployment file\"\n end\n\n opts = generate_options(:run, ec2_info, {\n :min_count => 1,\n :max_count => 1})\n\n # The OpenNebula context will be only included if not USERDATA\n # is provided by the user\n if !ec2_value(ec2_info, 'USERDATA')\n xml = OpenNebula::XMLElement.new\n xml.initialize_xml(xml_text, @provision_type == :host ? 'HOST' : 'VM')\n\n if xml.has_elements?('TEMPLATE/CONTEXT')\n # if requested, we generated cloud-init compatible data\n if ec2_value(ec2_info, 'CLOUD_INIT') =~ /^(yes|true)$/i\n context_str = generate_cc(xml, 'TEMPLATE/CONTEXT')\n else\n # Since there is only 1 level ',' will not be added\n context_str = xml.template_like_str('TEMPLATE/CONTEXT')\n\n if xml['TEMPLATE/CONTEXT/TOKEN'] == 'YES'\n # TODO use OneGate library\n token_str = generate_onegate_token(xml)\n if token_str\n context_str << \"\\nONEGATE_TOKEN=\\\"#{token_str}\\\"\"\n end\n end\n end\n\n userdata_key = EC2[:run][:args][\"USERDATA\"][:opt]\n opts[userdata_key] = Base64.encode64(context_str)\n end\n end\n\n instances = @ec2.create_instances(opts)\n instance = instances.first\n\n start_time = Time.now\n\n while Time.now - start_time < @state_change_timeout\n begin\n break if instance.exists?\n rescue => e\n OpenNebula::log_error(\"RESCUE: #{e.inspect}\")\n end\n\n sleep 2\n end\n\n tags = generate_options(:tags, ec2_info)[:tags] || {}\n\n tag_array = []\n tags.each{ |key,value|\n tag_array << {\n :key => key,\n :value => value\n }\n }\n\n instance.create_tags(:tags => tag_array) if tag_array.length > 0\n\n elastic_ip = ec2_value(ec2_info, 'ELASTICIP')\n\n wait_state('running', instance.id)\n\n if elastic_ip\n\n if elastic_ip.match(Resolv::IPv4::Regex)\n address_key = :public_ip\n else\n address_key = :allocation_id\n end\n\n address = {\n :instance_id => instance.id,\n address_key => elastic_ip\n }\n\n @ec2.client.associate_address(address)\n end\n\n if @provision_type == :host\n instance.create_tags(tags: [{\n key: 'Name',\n value: host['//HOST/TEMPLATE/PROVISION/HOSTNAME']\n },{\n key: 'ONE_HOST_ID',\n value: 'TODO'\n }])\n else\n instance.create_tags(tags: [{\n key: 'ONE_ID',\n value: id\n }])\n end\n\n puts(instance.id)\n end",
"def _deploy(zip_file, options={})\n request :deploy do |soap|\n soap.body = { :zip_file => zip_file, :deploy_options => options }\n end\n end",
"def install\n #python executable files\n end",
"def deploy\n project = Project.find(params[:project_id])\n location = project.locations.find(params[:location_id])\n location.deploy if location.present? && location.distance.present?\n\n head :ok\n end",
"def run(params={})\n # Extract params\n config_name = params.has_key?(:config_name) ? params[:config_name].to_sym : :default\n dry_run = params.has_key?(:dry_run) ? params[:dry_run] : false\n\n # Validate config\n error 'No deploy configuration found' if @site.config[:deploy].nil?\n error \"No deploy configuration found for #{config_name}\" if @site.config[:deploy][config_name].nil?\n\n # Set arguments\n src = File.expand_path(@site.config[:output_dir]) + '/'\n dst = @site.config[:deploy][config_name][:dst]\n options = @site.config[:deploy][config_name][:options] || DEFAULT_OPTIONS\n\n # Validate arguments\n error 'No dst found in deployment configuration' if dst.nil?\n error 'dst requires no trailing slash' if dst[-1,1] == '/'\n\n # Run\n if dry_run\n warn 'Performing a dry-run; no actions will actually be performed'\n run_shell_cmd([ 'echo', 'rsync', options, src, dst ].flatten)\n else\n run_shell_cmd([ 'rsync', options, src, dst ].flatten)\n end\n end",
"def run_for_deploy\n require_dsl\n\n return true if dsl.nil?\n run_check_classes(check_classes_named(dsl.deploy_checks))\n end",
"def compile\n Liberty.validate(@app_dir)\n @liberty_components_and_uris, @liberty_license = Liberty.find_liberty_files(@app_dir, @configuration)\n unless LibertyBuildpack::Util.check_license(@liberty_license, @license_id)\n print \"\\nYou have not accepted the IBM Liberty License.\\n\\nVisit the following uri:\\n#{@liberty_license}\\n\\nExtract the license number (D/N:) and place it inside your manifest file as a ENV property e.g. \\nENV: \\n IBM_LIBERTY_LICENSE: {License Number}.\\n\"\n raise\n end\n download_and_install_liberty\n link_application\n update_server_xml\n make_server_script_runnable\n download_and_install_features\n # Need to do minify here to have server_xml updated and applications and libs linked.\n minify_liberty if minify?\n overlay_java\n set_liberty_system_properties\n set_jdk_memory_configuration\n populate_class_cache if populate_class_cache_staging?\n end",
"def deploy number, archive, config_path, repository_base, binaries_base\n core_base = File.join(@base, number.to_s);\n FileUtils.mkdir_p core_base\n \n log.info \"deploying #{archive} to #{core_base} with config path #{config_path}\"\n \n command = \"#{Galaxy::HostUtils.tar} -C #{core_base} -zxf #{archive}\"\n begin\n Galaxy::HostUtils.system command\n rescue Galaxy::HostUtils::CommandFailedError => e\n raise \"Unable to extract archive: #{e}\"\n end\n \n xndeploy = \"#{core_base}/bin/xndeploy\"\n unless FileTest.executable? xndeploy\n xndeploy = \"/bin/sh #{xndeploy}\"\n end\n \n command = \"#{xndeploy} --base #{core_base} --binaries #{binaries_base} --config-path #{config_path} --repository #{repository_base}\"\n begin\n Galaxy::HostUtils.system command\n rescue Galaxy::HostUtils::CommandFailedError => e\n raise \"Deploy script failed: #{e}\"\n end\n return core_base\n end",
"def publish!\n mkdir_p File.join(self.publish_path, self.to_s)\n self.targets.each do |tgt|\n install File.join(self.to_s, tgt), File.join(self.publish_path, self.to_s, tgt)\n end\n end",
"def stage_wp_site\n # Note - this assumes that the wordpress files are saved in the repository that\n # the WPDeploy script will look for them in a particular directory\n begin \n if AppConfig.wp_deploy_enabled?\n LOGGER.debug \"Staging original wordpress site for project #{self.label}\"\n wpd = WpDeploy.new(self.label)\n wpd.deploy\n else\n LOGGER.info \"Skipping staging of WordPress site for #{self.label} as wp_deploy is disabled\"\n end\n rescue Exception => e\n LOGGER.error \"Error occurred staging original wordpress site: #{e.message}\"\n end\n end",
"def after_release_email(tag, note, type, selector, options) \n command = \"origen web compile --remote --api\" \n Dir.chdir Origen.root do \n system command \n end \n end",
"def exec\n FileUtils.cd(@dest) do\n puts \"Running `bundle install` in #{Dir.pwd}\"\n system(\"bundle install\")\n end\n end",
"def deploy_in_background! (opts={})\n unless Rails.env == 'test'\n logger.info \"Calling other ruby process in the background in order to deploy deployment #{self.id} (stage #{self.stage.id}/#{self.stage.name})\"\n system_command = \"sh -c \\\"cd #{Rails.root} && bundle exec rails runner -e #{Rails.env} ' deployment = Deployment.find(#{self.id}); deployment.prompt_config = #{self.prompt_config.inspect.gsub('\"', '\\\"')} ; Webistrano::Deployer.new(deployment).invoke_task! ' >> #{Rails.root}/log/#{Rails.env}.log 2>&1\\\" &\"\n logger.info \"SYSTEM_COMMAND: #{system_command}\"\n system(system_command)\n\n # Webistrano::Deployer.new(Deployment.find(self.id)).invoke_task!\n end\n end",
"def deploy(attrs)\n Deployment.deploy(api, self, attrs)\n end",
"def deploy()\n return Error.new('ID not defined') unless @id\n \n node_types().each do |node_type|\n node_type.set_action(\"DEPLOY\")\n end\n end",
"def deploy(path, options={})\n Job::Deploy.new(self, path, options)\n end",
"def push\n if File.exist?(@local)\n check_branch\n init_repo\n puts \"Syncing #{@local.sub(Dir.pwd.strip+'/', '')} files to #{@repo}.\"\n FileUtils.cd @deploy_dir do\n git_pull\n clean_deploy\n copy_site\n git_push\n end\n else\n abort \"Cannot find site build at #{@local}. Be sure to build your site first.\"\n end\n end",
"def start\n extract_and_configure\n if config.managed?\n @pid = spawn(config.env, *process_arguments)\n\n # Wait for fcrepo to start\n while !status\n sleep 1\n end\n end\n end",
"def create_project(tx)\n Installer.copy(tx, \"#{@service_dir}/pieces/public\", get_path(:web))\n true\n end",
"def run\n setup\n build_vm\n package_stemcell\n cleanup\n @target\n end",
"def run\n setup\n build_vm\n package_stemcell\n cleanup\n @target\n end",
"def prepare_deploy(t, args)\n set_verbosity(args)\n\n plugins_dir = Pathname.new(\"#{args.plugin_dir || '/var/tmp/bundles/plugins/ruby'}\").expand_path\n mkdir_p plugins_dir, :verbose => @verbose\n\n plugin_path = plugin_path(plugins_dir, false) # \"#{plugins_dir}/#{name}\"\n if plugin_path.exist?\n if args.force == \"true\"\n safe_unlink plugin_path # if link (deploy:dev) just remove the link\n if plugin_path.exist?\n @logger.info \"Deleting previous plugin deployment #{plugin_path}\"\n rm_rf plugin_path, :verbose => @verbose if plugin_path.exist?\n else\n @logger.info \"Unlinked previous plugin deployment #{plugin_path}\"\n end\n else\n raise \"Cowardly not deleting previous plugin deployment #{plugin_path} - override with rake #{t.name}[true]\"\n end\n end\n plugins_dir\n end",
"def deploy(id, drv_message)\n error = \"Action not implemented by driver #{self.class}\"\n send_message(ACTION[:deploy],RESULT[:failure],id,error)\n end",
"def run!\n # Validate paths\n validate_paths!\n \n # Extract mockup\n copy_source_path_to_build_path!\n \n validate_stack!\n \n # Run stack\n run_stack!\n \n # Run finalizers\n run_finalizers!\n \n # Cleanup\n cleanup! if self.config[:cleanup_build]\n \n end",
"def deploy(id, host, xml_text, lcm_state, deploy_id)\n if %w[BOOT BOOT_FAILURE].include? lcm_state\n one_info = get_deployment_info(host, xml_text)\n\n # load_default_template_values\n\n tid = one_value(one_info, 'TEMPLATE_ID')\n\n if tid.nil? || tid == ''\n STDERR.puts('Cannot find TEMPLATE_ID in deployment file')\n exit(-1)\n end\n\n extra_template = \"REMOTE_OPENNEBULA = YES\\n\"\\\n \"REMOTE_OPENNEBULA_VM_ID = #{id}\\n\"\n\n # The OpenNebula context will be included\n xml = OpenNebula::XMLElement.new\n xml.initialize_xml(xml_text, 'VM')\n\n if xml.has_elements?('TEMPLATE/CONTEXT')\n # Since there is only 1 level ',' will not be added\n context_str = xml.template_like_str('TEMPLATE/CONTEXT')\n\n if xml['TEMPLATE/CONTEXT/TOKEN'] == 'YES'\n # TODO: use OneGate library. See ec2_driver.rb\n token_str = generate_onegate_token(xml)\n if token_str\n context_str << \"\\nONEGATE_TOKEN=\\\"#{token_str}\\\"\"\n end\n end\n\n extra_template << context_str\n end\n\n t = OpenNebula::Template.new_with_id(tid, @client)\n rc = t.instantiate(REMOTE_NAME_PREFIX+id, true, extra_template,\n false)\n\n if OpenNebula.is_error?(rc)\n STDERR.puts(rc.to_str)\n exit(-1)\n end\n\n deploy_id = \"#{DEPLOY_ID_PREFIX}#{rc}\"\n vm = get_remote_vm(deploy_id)\n\n if !context_str.nil?\n new_context_update = 'CONTEXT = [' << context_str << ']'\n new_context_update = new_context_update.gsub(\"\\n\", \",\\n\")\n rc = vm.updateconf(new_context_update)\n end\n\n if OpenNebula.is_error?(rc)\n STDERR.puts(rc.to_str)\n exit(-1)\n end\n\n vm.release\n\n rc = vm.update(\"REMOTE_OPENNEBULA_DEPLOY_ID = \\\"#{deploy_id}\\\"\",\n true)\n\n if OpenNebula.is_error?(rc)\n STDERR.puts('Error adding REMOTE_OPENNEBULA_DEPLOY_ID ' \\\n \"attribute to VM #{rc}: #{rc.to_str}\")\n end\n\n puts(deploy_id)\n else\n restore(deploy_id)\n deploy_id\n end\n end",
"def action_deploy\n notifying_block do\n directory new_resource.path do\n owner new_resource.owner\n group new_resource.group\n mode '755'\n end\n end\n end",
"def deploy version\n\t\t\tprep_version version\n\t\t\tinstance = version.instantiate\n\t\t\tspin_up instance\n\t\tend",
"def deploy!(options={})\n params = {}\n params['api_key'] = @api_key\n params['deploy[rails_env]'] = options[:framework_env] || 'development'\n params['deploy[local_username]'] = options[:username] || %x(whoami).strip\n params['deploy[scm_repository]'] = options[:scm_repository]\n params['deploy[scm_revision]'] = options[:scm_revision]\n response(@deploy_url, params)\n end",
"def index\n branch = shift_argument || 'master'\n validate_arguments!\n\n Heroku::Auth.check\n\n unless remotes = git_remotes\n error('No Heroku remotes detected.'.red)\n end\n\n unless remote = remotes.key(app)\n error(\"Remote for #{app} was not found.\".red)\n end\n\n begin\n pack = Pack.detect.new(app, remote, options)\n pack.deploy!(branch)\n display('Deployment successful.'.green)\n rescue Pack::NotFound\n error('No suitable deploy pack found.'.red)\n rescue Pack::AmbiguousApp\n error('Ambiguous application, multiple deploy packs apply.'.red)\n rescue CommandExecutionFailure\n error('Deployment aborted.'.red.blink)\n end\n end",
"def deploy_modules\n password_prompt\n system %Q!mlpm install!\n system %Q!mlpm deploy -u #{ @properties['ml.user'] } \\\n -p #{ @ml_password } \\\n -H #{ @properties['ml.server'] } \\\n -P #{ @properties['ml.app-port'] }!\n original_deploy_modules\n end",
"def before_deploy_site \n Dir.chdir Origen.root do \n system \"origen examples -c\" \n dir = \"#{Origen.root}/web/output/coverage\" \n FileUtils.remove_dir(dir, true) if File.exists?(dir) \n system \"mv #{Origen.root}/coverage #{dir}\" \n end \n end",
"def start\n @pid = Process.fork do\n if (@options.rack) \n # NOTE: This does not support command-line setting of repo!\n opts = { :server => :webrick, :host => @host, :port => @port}\n PlanR::Application::LocalHttpd::WebApp.run!( repo, opts ) \n else\n # rack doesn't do the one thing we need it to: \n # pass WebApp instantiation arguments to Webrick.mount\n opts = { :BindAddress => @host, :Port => @port}\n @webrick = ::WEBrick::HTTPServer.new(opts)\n @webrick.mount \"/\", Servlet,\n [ PlanR::Application::LocalHttpd::WebApp, \n @options ]\n @webrick.start\n end\n end\n\n trap('INT') { Process.kill 'INT', @pid }\n trap('TERM') { Process.kill 'INT', @pid }\n\n self\n end",
"def deploy!\n if copy_cache\n if File.exists?(copy_cache)\n logger.debug \"refreshing local cache to revision #{revision} at #{copy_cache}\"\n system(source.sync(revision, copy_cache))\n else\n logger.debug \"preparing local cache at #{copy_cache}\"\n system(source.checkout(revision, copy_cache))\n end\n\n # Check the return code of last system command and rollback if not 0\n unless $? == 0\n raise Capistrano::Error, \"shell command failed with return code #{$?}\"\n end\n\n FileUtils.mkdir_p(destination)\n\n logger.debug \"copying cache to deployment staging area #{destination}\"\n Dir.chdir(copy_cache) do\n queue = Dir.glob(\"*\", File::FNM_DOTMATCH)\n while queue.any?\n item = queue.shift\n name = File.basename(item)\n\n next if name == \".\" || name == \"..\"\n next if copy_exclude.any? { |pattern| File.fnmatch(pattern, item) }\n\n if File.symlink?(item)\n FileUtils.ln_s(File.readlink(item), File.join(destination, item))\n elsif File.directory?(item)\n queue += Dir.glob(\"#{item}/*\", File::FNM_DOTMATCH)\n FileUtils.mkdir(File.join(destination, item))\n else\n FileUtils.ln(item, File.join(destination, item))\n end\n end\n end\n else\n logger.debug \"getting (via #{copy_strategy}) revision #{revision} to #{destination}\"\n system(command)\n\n if copy_exclude.any?\n logger.debug \"processing exclusions...\"\n if copy_exclude.any?\n copy_exclude.each do |pattern|\n delete_list = Dir.glob(File.join(destination, pattern), File::FNM_DOTMATCH)\n # avoid the /.. trap that deletes the parent directories\n delete_list.delete_if { |dir| dir =~ /\\/\\.\\.$/ }\n FileUtils.rm_rf(delete_list.compact)\n end\n end\n end\n end\n\n # merge stuffs under specific dirs\n if configuration[:merge_dirs]\n configuration[:merge_dirs].each do |dir, dest|\n from = Pathname.new(destination) + dir\n to = Pathname.new(destination) + dest\n logger.trace \"#{from} > #{to}\"\n FileUtils.mkdir_p(to)\n FileUtils.cp_r(Dir.glob(from), to)\n end\n end\n\n # for a rails application in sub directory\n # set :deploy_subdir, \"rails\"\n if configuration[:deploy_subdir]\n subdir = configuration[:deploy_subdir]\n logger.trace \"deploy subdir #{destination}/#{subdir}\"\n Dir.mktmpdir do |dir|\n FileUtils.move(\"#{destination}/#{subdir}\", dir)\n FileUtils.rm_rf destination rescue nil\n FileUtils.move(\"#{dir}/#{subdir}\", \"#{destination}\")\n end\n end\n\n File.open(File.join(destination, \"REVISION\"), \"w\") { |f| f.puts(revision) }\n\n logger.trace \"compressing #{destination} to #{filename}\"\n Dir.chdir(copy_dir) { system(compress(File.basename(destination), File.basename(filename)).join(\" \")) }\n\n distribute!\n ensure\n puts $! if $!\n FileUtils.rm filename rescue nil\n FileUtils.rm_rf destination rescue nil\n FileUtils.rm_rf copy_subdir rescue nil\n end",
"def install_server(project_path=nil)\n environments = Engineyard::Jenkins::AppcloudEnv.new.find_environments(options)\n if environments.size == 0\n no_environments_discovered and return\n elsif environments.size > 1\n too_many_environments_discovered(environments) and return\n end\n \n env_name, account_name, environment = environments.first\n if environment.instances.first\n public_hostname = environment.instances.first.public_hostname\n status = environment.instances.first.status\n end\n \n temp_project_path = File.expand_path(project_path || File.join(Dir.tmpdir, \"temp_jenkins_server\"))\n shell.say \"Temp installation dir: #{temp_project_path}\" if options[:verbose]\n \n FileUtils.mkdir_p(temp_project_path)\n FileUtils.chdir(temp_project_path) do\n # 'install_server' generator\n require 'engineyard-jenkins/cli/install_server_generator'\n Engineyard::Jenkins::InstallServerGenerator.start(ARGV.unshift(temp_project_path))\n\n say \"\"\n say \"Uploading to \"; say \"'#{env_name}' \", :yellow; say \"environment on \"; say \"'#{account_name}' \", :yellow; say \"account...\"\n require 'engineyard/cli/recipes'\n environment.tar_and_upload_recipes_in_cookbooks_dir\n\n if status == \"running\" || status == \"error\"\n say \"Environment is rebuilding...\"\n environment.run_custom_recipes\n watch_page_while public_hostname, 80, \"/\" do |req|\n req.body !~ /Please wait while Jenkins is getting ready to work/\n end\n\n say \"\"\n say \"Jenkins is starting...\"\n watch_page_while public_hostname, 80, \"/\" do |req|\n req.body =~ /Please wait while Jenkins is getting ready to work/\n end\n \n require 'jenkins'\n require 'jenkins/config'\n ::Jenkins::Config.config[\"base_uri\"] = public_hostname\n ::Jenkins::Config.store!\n \n say \"\"\n say \"Done! Jenkins CI hosted at \"; say \"http://#{public_hostname}\", :green\n else\n say \"\"\n say \"Almost there...\"\n say \"* Boot your environment via https://cloud.engineyard.com\", :yellow\n end\n end\n end",
"def deploy_maven\n puts '#### Start deploy maven ####'\n # Nexus requires XX.XX.XX.XX version numbers\n compiled_version = get_package_version + '.0'\n output = `mvn -X -B -s isso-settings-clm.xml deploy:deploy-file \\\n -Dpackaging=tar \\\n -Dfile=rule-engine-ui-client.tar \\\n -DgeneratePom=true \\\n -DgroupId=com.capitalone.dsd.ui \\\n -DartifactId=rule-engine-ui-client \\\n -Dversion=#{compiled_version} \\\n -DrepositoryId=nexus \\\n -Durl=https://nexus.kdc.capitalone.com/mother/service/local/staging/deploy/maven2 2>&1`\n puts output\n puts '#### Done deploy maven ####'\nend",
"def compile_project\n debug_msg \" compiling #{@project_name}\"\n system(HHC_PATH, @project_name)\n end"
] |
[
"0.74498004",
"0.73822",
"0.72867525",
"0.7238021",
"0.7143079",
"0.7062464",
"0.6823013",
"0.676205",
"0.6716412",
"0.6665663",
"0.6639183",
"0.6626383",
"0.6571943",
"0.65282935",
"0.6491921",
"0.64896834",
"0.6481388",
"0.6453284",
"0.6451391",
"0.6438518",
"0.643701",
"0.643701",
"0.63821393",
"0.6344945",
"0.6326398",
"0.6322214",
"0.6322207",
"0.6275246",
"0.6264414",
"0.6256947",
"0.62540513",
"0.6204295",
"0.6199046",
"0.6197901",
"0.617615",
"0.6173876",
"0.6173387",
"0.6170348",
"0.61649865",
"0.61509544",
"0.6130901",
"0.61250085",
"0.6106544",
"0.6105096",
"0.6098784",
"0.6086377",
"0.60612917",
"0.60511696",
"0.59752154",
"0.5969427",
"0.59641784",
"0.5957574",
"0.59513813",
"0.5920396",
"0.5920396",
"0.59102887",
"0.5901611",
"0.58903235",
"0.58787495",
"0.5870001",
"0.58499515",
"0.58424526",
"0.5816118",
"0.58037615",
"0.5800089",
"0.5797283",
"0.57941705",
"0.57912827",
"0.5769207",
"0.5753595",
"0.57446975",
"0.5733777",
"0.5733477",
"0.5729088",
"0.5722895",
"0.57209164",
"0.57195336",
"0.57178724",
"0.57095826",
"0.57029366",
"0.56994426",
"0.5698486",
"0.5697091",
"0.56808656",
"0.56808376",
"0.568017",
"0.5677485",
"0.5673203",
"0.56609106",
"0.56545734",
"0.56520796",
"0.5648985",
"0.5644842",
"0.5642985",
"0.5631167",
"0.5625635",
"0.56118727",
"0.5605806",
"0.5604329",
"0.5600607"
] |
0.64958453
|
14
|
Method that initiates deploy of project source code
|
def deploySource
verifyOS
timeDate = Time.new
vConfig(CONFIG['configWebsite'])
read_json(CONFIG['configWebsite'])
branchSource = @parse_json_config['deploy']['branch']['source']
msgCommit = @parse_json_config['deploy']['github']['config']['commit']
add_repo_git(".")
add_remoteurl(".")
pull_execute(branchSource, ".")
git_checkout(branchSource, ".")
system_commands("echo Deploy source files. Wait ...")
system_commands("git add .")
system_commands("git commit -m \"#{msgCommit} - #{timeDate.inspect}\"")
system_commands("git push origin -u #{branchSource}")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def deploy()\n release = create_release_name()\n\n write_deploy_version_file()\n\n DirectorySync.sync(server, from_dir, cache_dir, server[:deployer])\n copy_cache_dir_to_release(release)\n\n symlink_shared_directories(release)\n\n send_scripts()\n run_script(:before, release)\n symlink_release_dir(release)\n run_script(:after, release)\n end",
"def deploy\n unless ITEMS[:project].has_value? SETTINGS[:project]\n raise \"Invalid project: #{SETTINGS[:project]}.\"\n end\n\n # Call the original deploy method.\n orig_deploy\n end",
"def deploySite\n verifyOS\n timeDate = Time.new\n vConfig(CONFIG['configWebsite'])\n read_json(CONFIG['configWebsite'])\n compileP = @parse_json_config['deploy']['compile']['built']\n branchBuilt = @parse_json_config['deploy']['branch']['built']\n msgCommit = @parse_json_config['deploy']['github']['config']['commit']\n if compileP == \"yes\"\n system_commands(\"rake build\")\n end\n # enter_folder(\"./_site\") # DEPRECATED\n add_repo_git(SITEDIR)\n add_remoteurl(SITEDIR)\n pull_execute(branchBuilt, SITEDIR)\n system_commands(\"echo Deploy source files. Wait ...\")\n git_checkout(branchBuilt, SITEDIR)\n system_commands(\"cd #{SITEDIR}; git add .\")\n system_commands(\"cd #{SITEDIR}; git commit -m \\\"#{msgCommit} - #{timeDate.inspect}\\\"\")\n system_commands(\"cd #{SITEDIR}; git push origin -u #{branchBuilt}\")\n\n end",
"def deploy\n @operation = \"Deploy\"\n build_env = project[:build_env] || \"\"\n\n prepare_local_dir do\n run_cmd \"cap -q deploy #{build_env}\"\n run_cmd \"cap -q deploy:migrate #{build_env}\"\n run_cmd \"cap -q deploy:cleanup #{build_env}\"\n end\n end",
"def perform_deployment\n \tself.started_at = Time.now \t\n \tline = Cocaine::CommandLine.new(\"cd /home/mohkhan.Desktop/SFDC_DeplomentScripts && perl fetch_and_deploy.pl -r #{self.release} -d <#{self.target_config_name}> --mode=#{self.mode}\")\n \tline.run\n \tself.ended_at = Time.now\n \tself.status = \"deployed\"\n \tself.save\n end",
"def deploy\n if phase.has_key?('deploy')\n execute(\"deploy\", phase['deploy'])\n end\n end",
"def prepare_deploy\n `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy:setup -S phase=node_prepare HOSTS=#{self.hostname}`\n `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy -S phase=node_prepare HOSTS=#{self.hostname}`\n end",
"def default_deploy\n setup\n update_repo_tag\n push_repo\n maintenance_mode do\n run_migrations\n app_restart\n end\n warm_instance\n teardown\n end",
"def action_deploy\n set_state\n notifying_block do\n write_config\n run_syncdb\n run_migrate\n run_collectstatic\n end\n end",
"def deploy_application\n deploy(selfdir + \"app\")\n end",
"def deploy repository, branch\n\n super do\n section \"Installing dependencies with #{`bundle -v`.chomp}...\" do\n install_dependencies\n end\n\n section \"Precompiling assets...\" do\n precompile_assets\n end if precompile_assets?\n end\n\n end",
"def deploy\n update_repositories\n sync_service_environment_files\n # deploy_services\n response\n end",
"def run(params={})\n config_name = params.has_key?(:config_name) ? params[:config_name].to_sym : :default\n\n # Validate config\n error 'No deploy configuration found' if @site.config[:deploy].nil?\n error \"No deploy configuration found for #{config_name}\" if @site.config[:deploy][config_name].nil?\n \n src_branch = @site.config[:deploy][config_name][:src_branch]\n dst_branch = @site.config[:deploy][config_name][:dst_branch]\n dst_remote = @site.config[:deploy][config_name][:dst_remote]\n \n error 'No source branch found in deployment configuration' if src_branch.nil?\n error 'No destination branch found in deployment configuration' if dst_branch.nil?\n error 'No destination remote found in deployment configuration' if dst_remote.nil?\n \n git = ::Git::Base.open('.')\n \n # Compile the site from scratch\n Nanoc::Tasks::Clean.new(@site).run\n \n # Check out the source branch\n puts \"Checking out #{src_branch}.\"\n git.checkout(src_branch)\n \n # Compile the site from scratch\n puts \"Compiling site.\"\n @site.compiler.run\n \n # Check out the destination branch\n puts \"Checking out destination branch.\"\n git.checkout(dst_branch)\n \n # Copy output files recursively into the current directory\n puts \"Copying files.\"\n FileUtils.cp_r(@site.config[:output_dir].chomp('/') + '/.', '.')\n \n # Automatically add and commit changes\n puts \"Committing changes.\"\n git.add\n git.commit(\"updated #{Time.now.to_s}\", :add_all => true)\n \n # Push changes to the destination repo/branch\n puts \"Pushing to #{dst_remote} #{dst_branch}.\"\n git.push(dst_remote, dst_branch)\n \n # Switch back to the source branch\n puts \"Checking out #{src_branch}.\"\n git.checkout(src_branch)\n end",
"def action_before_deploy\n install_packages\n end",
"def create\n deploy\n end",
"def deploy!\n write_previous_revision\n update_repository\n write_revision\n end",
"def deploy\n\t\t\tdeployPlanString = @repo.get_file_content('.deploy_plan.xml',@params['commit']||@params['branch'])\n\t\t\txmlRoot = XmlUtils.get_xml_root(deployPlanString)\n\t\t\t# select plan\n\t\t\tplanNode = XmlUtils.single_node(xmlRoot,'plan')\n\t\t\t# for each deploy\n\t\t\tdeployNode = XmlUtils.single_node(planNode,'deploy')\n\t\t\t# create client for kind/method\n\t\t\t@site_client = DesignShell::SiteClient.new({\n\t\t\t\t:site_url => @params['site_url'],\n\t\t\t\t:site_username => @params['site_username'],\n\t\t\t\t:site_password => @params['site_password'],\n\t\t\t})\n\t\t\tds = @site_client.deploy_status\n\t\t\tsite_repo_url = ds && ds['repo_url'].to_nil\n\t\t\tsite_branch = ds && ds['branch'].to_nil\n\t\t\tsite_commit = ds && ds['commit'].to_nil\n\t\t\trepo_url = @repo.url\n\t\t\t# @todo must limit uploads to build folder\n\t\t\tfromPath = MiscUtils.ensure_slashes(XmlUtils.peek_node_value(deployNode,'fromPath','/'),false,true) # eg. /build/bigcommerce effectively selects a subfolder that should be debased\n\t\t\ttoPath = MiscUtils.ensure_slashes(XmlUtils.peek_node_value(deployNode,'toPath','/'),false,true) # eg. / effectively the new base for these files\n\t\t\tif site_repo_url && site_repo_url==repo_url && site_branch && site_commit\n\t\t\t\t# incremental\n\t\t\t\tchanges = @repo.changesBetweenCommits(site_commit,@repo.head.to_s)\n\t\t\t\tuploads,deletes = convertChangesToUploadsDeletes(changes)\n\t\t\t\tuploads.delete_if { |fp| !fp.begins_with?(fromPath) }\n\t\t\t\tdeletes.delete_if { |fp| !fp.begins_with?(fromPath) }\n\t\t\t\t@site_client.delete_files(deletes,fromPath,toPath)\n\t\t\t\t@site_client.upload_files(@repo.path,uploads,fromPath,toPath)\n\t\t\t\t@site_client.deploy_status = {\n\t\t\t\t\t:repo_url => @repo.url,\n\t\t\t\t\t:branch => @repo.branch,\n\t\t\t\t\t:commit => @repo.head.to_s,\n\t\t\t\t :fromPath => fromPath,\n\t\t\t\t :toPath => toPath\n\t\t\t\t}\n\t\t\telse\n\t\t\t\t# complete\n\t\t\t\t# for now, just deploy all files in wd, creating folders as necessary\n\t\t\t\t# later, delete remote files not in wd except for eg. .deploy-status.xml and perhaps upload folders\n\t\t\t\tuploads = MiscUtils.recursive_file_list(@repo.path,false)\n\t\t\t\tuploads.delete_if do |fp|\n\t\t\t\t\t!fp.begins_with?(fromPath) || fp.begins_with?('.git/')\n\t\t\t\tend\n\t\t\t\t@site_client.upload_files(@repo.path,uploads,fromPath,toPath)\n\t\t\t\t@site_client.deploy_status = {\n\t\t\t\t\t:repo_url => @repo.url,\n\t\t\t\t\t:branch => @repo.branch,\n\t\t\t\t\t:commit => @repo.head.to_s,\n\t\t\t\t\t:fromPath => fromPath,\n\t\t :toPath => toPath\n\t\t\t\t}\n\t\t\tend\n\t\tend",
"def deploy\n\t# This task is typiclly run after the site is updated but before the server is restarted.\nend",
"def deploy\n\t# This task is typiclly run after the site is updated but before the server is restarted.\nend",
"def deploy\n unless serverside_version\n # only set serverside version if it's not set, to imitate the api\n # behavior of choosing its own serverside version if one is not\n # sent\n update :serverside_version => AWSM_SERVERSIDE_VERSION\n end\n finished!(\n :successful => true,\n :output => 'Deployment triggered by the API'\n )\n end",
"def deploy\n Kb8Run.update_context(@kb8context)\n @deploy_units.each do | deploy_unit |\n deploy_unit.deploy\n end\n end",
"def create_deploy\n @@tpl = CapistranoDeployGenerator.source_root\n empty_directory \"config/deploy\"\n\n say <<-EOF\n\nconfig/deploy.rb generator\n\nThis menu will help you creating deployment configuration file\ndeploy.rb for Capistrano. It is safe to acceppt defulat values for\nmost or all questions. Just hit Enter if default is provided.\n\nAll values can be changed later in the file itself or you can re-run\ngenerator again.\n\nEOF\n template \"deploy.rb.erb\", \"config/deploy.rb\"\n @stages.each do |stage|\n template \"staging.rb.erb\", \"config/deploy/#{stage}.rb\" \n end\n say \"Please edit manually configuration of the multi-staging files:\"\n @stages.map { |x| say \"./confg/deploy/#{x}.rb\\n\"}\n end",
"def deploy\n Tipsy::Runners::Deployer.new\n end",
"def install\n \n end",
"def deploy\n what = ARGV.shift\n\n case what\n when 'packages'\n deploy_packages\n else\n ARGV.unshift what\n original_deploy\n end\n end",
"def prepare_for_installation; end",
"def install\n end",
"def install\n end",
"def deploy(&block)\n in_directory do\n self.setup!\n self.push_with_retry!\n block.call(self, platform_api, output) if block_given?\n end\n ensure\n self.teardown!\n end",
"def install\n end",
"def deploy?; run_options[:deploy]; end",
"def initial_deployment\n raise NotImplementedError\n end",
"def run\n case action\n when 'new'\n require_relative('templater')\n Templater.new(File.expand_path(directory, Dir.pwd), settings).run!\n when 'console'\n require_relative('console')\n Wukong::Deploy::Console.new.run!\n end\n end",
"def deploy\n system %Q[ssh -lroot \"#{server}\" <<'EOF'\n \tcat >\"#{remote_script_name}\" <<'EOS'\n#{generate}EOS\nchmod +x \"#{remote_script_name}\"\nsource \"#{remote_script_name}\"\nEOF\n ]\n end",
"def install\n #python executable files\n end",
"def setup_files\n create_application_rb\n create_production_rb\n end",
"def init_project(*args)\n # anything to do?\n end",
"def add_post_deploy_resources\n if new_resource.precompile_assets\n app_local = app\n username = user_username\n ruby_block 'precompile assests' do\n block do\n require 'bundler'\n bundle_precompile_command = \"sudo su - #{username} -c 'cd #{app_local.release_path} \"\\\n \"&& source ./.env && #{app_local.bundle_binary} exec rake #{new_resource.precompile_command}'\"\n\n Bundler.clean_system(bundle_precompile_command)\n raise('Bundle pre-compile failed') unless $CHILD_STATUS.exitstatus.zero?\n end\n action :nothing\n subscribes :run, \"deploy_revision[#{new_resource.name}]\", :immediate\n end\n end\n\n super\n end",
"def deploy\n cmd = \"deploy #{@resource[:source]} --name=#{@resource[:name]}#{runtime_name_param_with_space_or_empty_string}\"\n if @resource[:runasdomain]\n cmd = append_groups_to_cmd(cmd, @resource[:servergroups])\n end\n cmd = \"#{cmd} --force\" if force_deploy?\n display_lines 100\n bring_up 'Deployment', cmd\n @resource[:name]\n end",
"def install\n run \"bundle exec backup generate:config --config-path=config/backup\" unless File.exists?(\"config/backup/config.rb\")\n template \"general.rb\", \"config/backup/models/general.rb\"\n if File.exists? \".env\"\n append_file \".env\" do\n File.read(File.expand_path(find_in_source_paths('env.env')))\n end\n else\n template \"env.env\", \".env\"\n end\n run \"bundle exec wheneverize .\" unless File.exists?(\"config/schedule.rb\")\n append_file \"config/schedule.rb\" do\n File.read(File.expand_path(find_in_source_paths('schedule.rb')))\n end\n end",
"def pre_install; end",
"def deploy(package_path, opts={}, &block)\n end",
"def post_install_actions\n Dir.chdir(@project_name) do\n SemVer.new.save(SemVer::FILE_NAME)\n end\n end",
"def perform\n validate_system_config\n\n deployment_name = \"#{system_config.system_name}-core\"\n\n manifest = base_manifest(\n deployment_name,\n bosh_config.target_uuid,\n system_config.bosh_provider,\n system_config.system_name,\n system_config.release_name,\n system_config.release_version,\n system_config.stemcell_name,\n system_config.stemcell_version,\n cloud_properties_for_server_flavor(system_config.core_server_flavor),\n system_config.core_ip,\n system_config.root_dns,\n system_config.admin_emails,\n system_config.common_password,\n system_config.common_persistent_disk,\n system_config.security_group\n )\n\n dea_config.build_into_manifest(manifest)\n system_config.services.each do |service_config|\n service_config.build_into_manifest(manifest)\n end\n\n chdir system_config.system_dir do\n mkdir_p(\"deployments\")\n File.open(\"deployments/#{system_config.system_name}-core.yml\", \"w\") do |file|\n file << manifest.to_yaml\n end\n end\n end",
"def deploy(id, host, remote_dfile, not_used)\n error = \"Action not implemented by driver #{self.class}\"\n send_message(ACTION[:deploy],RESULT[:failure],id,error)\n end",
"def remote_deploy(options={})\n @cartridge_model.do_control('update-configuration',\n @cartridge_model.primary_cartridge,\n pre_action_hooks_enabled: false,\n post_action_hooks_enabled: false,\n out: options[:out],\n err: options[:err])\n\n deploy(options)\n\n if options[:init]\n primary_cart_env_dir = PathUtils.join(@container_dir, @cartridge_model.primary_cartridge.directory, 'env')\n primary_cart_env = ::OpenShift::Runtime::Utils::Environ.load(primary_cart_env_dir)\n ident = primary_cart_env.keys.grep(/^OPENSHIFT_.*_IDENT/)\n _, _, version, _ = Runtime::Manifest.parse_ident(primary_cart_env[ident.first])\n\n @cartridge_model.post_install(@cartridge_model.primary_cartridge,\n version,\n out: options[:out],\n err: options[:err])\n\n end\n end",
"def run_predeploy\n super do\n update_task_revision\n\n begin\n @deploy_config.predeploy_commands.each { |command| run_command(command) }\n ensure\n EcsManager.deregister_last_n_tasks_definitions(family, 1)\n end\n end\n end",
"def before_deploy_site\n create\n end",
"def publish!\n mkdir_p File.join(self.publish_path, self.to_s)\n self.targets.each do |tgt|\n install File.join(self.to_s, tgt), File.join(self.publish_path, self.to_s, tgt)\n end\n end",
"def do_deploy()\n require 'digest/md5'\n require 'aws-sdk'\n require 'progressbar'\n require 'simple-cloudfront-invalidator'\n require 'yaml'\n\n # Validation check for environment variables\n if (!ENV['AWS_S3_BUCKET'] ||\n !ENV['AWS_ACCESS_KEY_ID'] ||\n !ENV['AWS_SECRET_ACCESS_KEY'] ||\n !ENV['AWS_CLOUDFRONT_DIST_ID'] ||\n !ENV['AWS_HOST_NAME'] )\n puts(\"The below required environment variable(s) have not been defined.\\n\"\\\n \"Without them, the Deploy process cannot complete.\\n\"\\\n \"Please verify that they have been correctly defined.\")\n puts(\" * AWS_S3_BUCKET\") if (!ENV['AWS_S3_BUCKET'])\n puts(\" * AWS_ACCESS_KEY_ID\") if (!ENV['AWS_ACCESS_KEY_ID'])\n puts(\" * AWS_SECRET_ACCESS_KEY\") if (!ENV['AWS_SECRET_ACCESS_KEY'])\n puts(\" * AWS_CLOUDFRONT_DIST_ID\") if (!ENV['AWS_CLOUDFRONT_DIST_ID'])\n puts(\" * AWS_HOST_NAME\") if (!ENV['AWS_HOST_NAME'])\n exit()\n end\n\n puts(\"========================================\")\n puts(\"Beginning Deploy Process...\")\n\n # Capture Hugo's config.yaml while we're in the same directory\n config_file = YAML.load_file('config.yaml')\n\n # Make sure we actually loaded a file, and didn't just set `config_file` to\n # the string \"config.yaml\".\n if (config_file == \"config.yaml\")\n Kernel.abort(\"ERROR: Could not find 'config.yaml'. Are you running Rake \"\\\n \"from the correct directory?\")\n end\n\n # Move into the Hugo destination directory, so file names are only prefixed\n # with \"./\"\n Dir.chdir(File.join(Dir.pwd, \"#{$hugo_dest}\"))\n\n # Generate a list of every file in $hugo_dest, and `map` them into the form,\n # [[\"«file_name»\", \"«md5sum»\"], ... ]\n puts(\" Aggregating Local Hash List...\")\n local_file_list = Dir[\"./**/*\"]\n .select { |f| File.file?(f) }\n .sort_by { |f| f }\n .map { |f|\n # The file names have a leading `./`. Strip those.\n [f[2..-1], Digest::MD5.file(f).hexdigest] }\n\n\n # Open up a connection to our S3 target bucket\n puts(\" Opening S3 Connection...\")\n aws_bucket = Aws::S3::Bucket.new(ENV['AWS_S3_BUCKET'], {\n :region => \"us-east-1\",\n :access_key_id => ENV['AWS_ACCESS_KEY_ID'],\n :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'],\n })\n\n # Fetch all objects from the remote, and `map` them into the form,\n # [[\"«file_name»\", \"«md5sum»\"], ... ]\n puts(\" Fetching Remote Object List (this may take up to ~30 seconds)...\")\n aws_file_list = aws_bucket\n .objects()\n .sort_by { |objs| objs.key }\n .map { |objs|\n # the etag (which is the md5sum) is wrapped in double-quotes. Strip those\n # by 'translating' them into empty strings.\n [objs.key, objs.etag.tr('\"','')] }\n\n\n # Now that we have the two lists, we need to compare them and generate the\n # list of files we need to upload, and the list of files we need to delete.\n # To do this, we're going to use some brute force.\n puts(\" Comparing Object Hashes...\")\n new_list = []\n updated_list = []\n delete_list = []\n lcl_i = 0\n aws_i = 0\n lcl_len = local_file_list.length\n aws_len = aws_file_list.length\n progress = ProgressBar.new(\" Hash check\", lcl_len)\n while true\n # Check if we've reached the end of either list and should break\n break if (lcl_i == lcl_len || aws_i == aws_len)\n lcl_file_name = local_file_list[lcl_i][0]\n aws_file_name = aws_file_list[aws_i][0]\n\n # Compare the file/object names\n case lcl_file_name <=> aws_file_name\n when 0 # File names are identical\n # Compare md5sums. If they don't match, add the file to the updated list.\n if (local_file_list[lcl_i][1] != aws_file_list[aws_i][1])\n updated_list.push(lcl_file_name)\n end\n # In either case, increment both index variables\n lcl_i += 1; progress.inc\n aws_i += 1\n when -1 # Local file name sorts first...\n # The local file doesn't exist on AWS. Add it to the new list.\n new_list.push(lcl_file_name)\n # And only increment the local index variable.\n lcl_i += 1; progress.inc\n when 1 # AWS object name sorts first...\n # The AWS object doesn't (or no longer) exist in the locally built\n # artifacts. Schedule it for deletion.\n delete_list.push(aws_file_name)\n # And only increment the aws index variable.\n aws_i += 1\n end\n end\n\n # If we're not at the end of the local file list, we need to add any new files\n # to the new list.\n while (lcl_i < lcl_len)\n new_list.push(local_file_list[lcl_i][0])\n lcl_i += 1; progress.inc\n end\n\n # If we're not at the end of the aws object list, we need to add those file to\n # the delete list.\n while (aws_i < aws_len)\n delete_list.push(aws_file_list[aws_i][0])\n aws_i += 1\n end\n progress.finish\n\n upload_list = updated_list + new_list\n\n puts(\" Hash Check complete\")\n puts(\" #{new_list.length} new files, and #{updated_list.length} updated..\")\n puts(\" #{upload_list.length} files need to be uploaded to the remote\")\n puts(\" #{delete_list.length} files need to be deleted from the remote\")\n current_time = Time.now.getutc.to_s.gsub(\" \",\"_\")\n File.open(\"new_file_list-#{current_time}.txt\", \"w+\") do |f|\n f.puts(new_list)\n end\n File.open(\"updated_file_list-#{current_time}.txt\", \"w+\") do |f|\n f.puts(upload_list)\n end\n File.open(\"deleted_list-#{current_time}.txt\", \"w+\") do |f|\n f.puts(delete_list)\n end\n\n\n # Upload the files in the upload updated and new lists, and delete the files\n # in the delete list.\n if (upload_list.length > 0)\n puts(\" Uploading files...\")\n progress = ProgressBar.new(\" Uploads\", upload_list.length)\n upload_list.each { |obj_path|\n #TODO: Generate a log of the uploaded files?\n #TODO: Error checking.\n #TODO: Stop publishing read/write.\n aws_bucket.put_object({\n acl: \"public-read-write\",\n key: obj_path,\n body: File.open(obj_path)\n })\n progress.inc\n }\n progress.finish\n else\n puts(\" No files to upload...\")\n end\n\n if (delete_list.length > 0)\n delete_list.each_slice(1000).with_index do |slice, index|\n index_from = index * 1000\n index_to = ((index+1)*1000) < delete_list.length ? ((index+1)*1000) : delete_list.length\n puts(\" Requesting Batch Delete for objects #{index_from}-#{index_to}...\")\n # Generate a Aws::S3::Types::Delete hash object.\n delete_hash = {\n delete: {\n objects: slice.map{ |f| { key: f } },\n quiet: false\n }\n }\n #TODO: Generate a log of the deleted files?\n begin\n response = aws_bucket.delete_objects(delete_hash)\n rescue Exception => e\n require 'pp'\n Kernel.abort(\"ERRROR: Batch Deletion returned with errors.\\n\"\\\n \" Delete Hash Object:\\n\"\\\n \"#{pp(delete_hash)}\\n\"\\\n \" Error message:\\n\"\\\n \"#{e.message}\")\n end\n if (response.errors.length > 0)\n require 'pp'\n Kernel.abort(\"ERRROR: Batch Deletion returned with errors\\n\"\\\n \" Delete Hash Object:\\n\"\\\n \"#{pp(delete_hash)}\\n\"\\\n \" Response Object:\\n\"\\\n \"#{pp(response)}\")\n end\n end\n else\n puts(\" No files to delete...\")\n end\n\n # Fetch and rewrite the S3 Routing Rules to make sure the 'latest' of every\n # project correctly re-route.\n puts(\" Configuring S3 Bucket Website redirect rules...\")\n\n # Open an S3 connection to the Bucket Website metadata\n aws_bucket_website = Aws::S3::BucketWebsite.new(ENV['AWS_S3_BUCKET'], {\n :region => \"us-east-1\",\n :access_key_id => ENV['AWS_ACCESS_KEY_ID'],\n :secret_access_key => ENV['AWS_SECRET_ACCESS_KEY'],\n })\n\n # Build the routing rules based on the config.yaml's 'project_descripts'. One\n # routing rule per project.\n routing_rules = []\n config_file['params']['project_descriptions'].each do |project, description|\n path = description['path']\n archived_path = description['archived_path']\n ver = description['latest']\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{archived_path}/latest/\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{archived_path}/latest\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{path}/latest/\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"#{path}/latest\" },\n :redirect => { :replace_key_prefix_with => \"#{path}/#{ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n end\n #TODO: We need to implement some way of adding arbitrary routing rules. Maybe\n # add a section in config.yaml that's just a JSON string that we parse?\n riak_path = config_file['params']['project_descriptions']['riak_kv']['path']\n riak_ver = config_file['params']['project_descriptions']['riak_kv']['latest']\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"riakee/latest/\" },\n :redirect => { :replace_key_prefix_with => \"#{riak_path}/#{riak_ver}/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"riakee/latest\" },\n :redirect => { :replace_key_prefix_with => \"#{riak_path}/#{riak_ver}\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n routing_rules.push(\n {\n :condition => { :key_prefix_equals => \"riakts/\" },\n :redirect => { :replace_key_prefix_with => \"riak/ts/\",\n :host_name => ENV['AWS_HOST_NAME'] }\n }\n )\n\n new_website_configuration = {\n :error_document => {:key => \"404.html\"},\n :index_document => aws_bucket_website.index_document.to_hash,\n :routing_rules => routing_rules\n }\n\n aws_bucket_website.put({ website_configuration: new_website_configuration })\n\n # Invalidate any files that were deleted or modified.\n cf_client = SimpleCloudfrontInvalidator::CloudfrontClient.new(\n ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'],\n ENV['AWS_CLOUDFRONT_DIST_ID'])\n invalidation_list = updated_list + delete_list\n if (invalidation_list.length == 0)\n puts(\" No files to invalidate...\")\n elsif (invalidation_list.length < 500)\n # The invalidation list is sufficiently short that we can invalidate each\n # individual file\n invalidation_list.each_slice(100).with_index do |slice, index|\n index_from = (index*100)\n index_to = ((index+1)*100) < delete_list.length ? ((index+1)*100) : delete_list.length\n puts(\" Sending Invalidation Request for objects #{index_from}-#{index_to}...\")\n cf_report = cf_client.invalidate(slice)\n end\n else\n # The invalidation list is large enough that we should skip getting charged\n # and invalidate the entire site.\n puts(\" Sending Invalidation Request for the entire site (\\\"/*\\\")...\")\n cf_report = cf_client.invalidate(['/*'])\n end\n\n puts(\"\")\n puts(\"Deploy Process Complete!\")\n puts(\"========================================\")\nend",
"def deploy(id, host, xml_text, lcm_state, deploy_id)\n # Restore if we need to\n if lcm_state != \"BOOT\" && lcm_state != \"BOOT_FAILURE\"\n restore(deploy_id)\n return deploy_id\n end\n\n # Otherwise deploy the VM\n\n begin\n ec2_info = get_deployment_info(host, xml_text)\n rescue Exception => e\n raise e\n end\n\n load_default_template_values\n\n if !ec2_value(ec2_info, 'AMI')\n raise \"Cannot find AMI in deployment file\"\n end\n\n opts = generate_options(:run, ec2_info, {\n :min_count => 1,\n :max_count => 1})\n\n # The OpenNebula context will be only included if not USERDATA\n # is provided by the user\n if !ec2_value(ec2_info, 'USERDATA')\n xml = OpenNebula::XMLElement.new\n xml.initialize_xml(xml_text, @provision_type == :host ? 'HOST' : 'VM')\n\n if xml.has_elements?('TEMPLATE/CONTEXT')\n # if requested, we generated cloud-init compatible data\n if ec2_value(ec2_info, 'CLOUD_INIT') =~ /^(yes|true)$/i\n context_str = generate_cc(xml, 'TEMPLATE/CONTEXT')\n else\n # Since there is only 1 level ',' will not be added\n context_str = xml.template_like_str('TEMPLATE/CONTEXT')\n\n if xml['TEMPLATE/CONTEXT/TOKEN'] == 'YES'\n # TODO use OneGate library\n token_str = generate_onegate_token(xml)\n if token_str\n context_str << \"\\nONEGATE_TOKEN=\\\"#{token_str}\\\"\"\n end\n end\n end\n\n userdata_key = EC2[:run][:args][\"USERDATA\"][:opt]\n opts[userdata_key] = Base64.encode64(context_str)\n end\n end\n\n instances = @ec2.create_instances(opts)\n instance = instances.first\n\n start_time = Time.now\n\n while Time.now - start_time < @state_change_timeout\n begin\n break if instance.exists?\n rescue => e\n OpenNebula::log_error(\"RESCUE: #{e.inspect}\")\n end\n\n sleep 2\n end\n\n tags = generate_options(:tags, ec2_info)[:tags] || {}\n\n tag_array = []\n tags.each{ |key,value|\n tag_array << {\n :key => key,\n :value => value\n }\n }\n\n instance.create_tags(:tags => tag_array) if tag_array.length > 0\n\n elastic_ip = ec2_value(ec2_info, 'ELASTICIP')\n\n wait_state('running', instance.id)\n\n if elastic_ip\n\n if elastic_ip.match(Resolv::IPv4::Regex)\n address_key = :public_ip\n else\n address_key = :allocation_id\n end\n\n address = {\n :instance_id => instance.id,\n address_key => elastic_ip\n }\n\n @ec2.client.associate_address(address)\n end\n\n if @provision_type == :host\n instance.create_tags(tags: [{\n key: 'Name',\n value: host['//HOST/TEMPLATE/PROVISION/HOSTNAME']\n },{\n key: 'ONE_HOST_ID',\n value: 'TODO'\n }])\n else\n instance.create_tags(tags: [{\n key: 'ONE_ID',\n value: id\n }])\n end\n\n puts(instance.id)\n end",
"def run\n unless !@valid_name || File.exists?(@project_name) || File.directory?(@project_name)\n $stdout.puts \"Creating goliath application under the directory #{@project_name}\"\n FileUtils.mkdir @project_name\n \n create_base_dirs\n copy_files_to_target\n setup_api_module\n copy_files_to_dir 'application.rb','config'\n copy_files_to_dir 'database.yml','config'\n $stdout.puts \"\\e[1;32m \\trun\\e[0m\\tbundle install\"\n Dir.chdir(\"#{@project_name}\")\n system(\"bundle install\")\n else \n unless !@valid_name\n $stdout.puts \"\\e[1;31mError:\\e[0m The directory #{@project_name} already exists, aborting. Maybe move it out of the way before continuing.\"\n end\n end\n end",
"def deploy(id, host, xml_text, lcm_state, deploy_id)\n if %w[BOOT BOOT_FAILURE].include? lcm_state\n one_info = get_deployment_info(host, xml_text)\n\n # load_default_template_values\n\n tid = one_value(one_info, 'TEMPLATE_ID')\n\n if tid.nil? || tid == ''\n STDERR.puts('Cannot find TEMPLATE_ID in deployment file')\n exit(-1)\n end\n\n extra_template = \"REMOTE_OPENNEBULA = YES\\n\"\\\n \"REMOTE_OPENNEBULA_VM_ID = #{id}\\n\"\n\n # The OpenNebula context will be included\n xml = OpenNebula::XMLElement.new\n xml.initialize_xml(xml_text, 'VM')\n\n if xml.has_elements?('TEMPLATE/CONTEXT')\n # Since there is only 1 level ',' will not be added\n context_str = xml.template_like_str('TEMPLATE/CONTEXT')\n\n if xml['TEMPLATE/CONTEXT/TOKEN'] == 'YES'\n # TODO: use OneGate library. See ec2_driver.rb\n token_str = generate_onegate_token(xml)\n if token_str\n context_str << \"\\nONEGATE_TOKEN=\\\"#{token_str}\\\"\"\n end\n end\n\n extra_template << context_str\n end\n\n t = OpenNebula::Template.new_with_id(tid, @client)\n rc = t.instantiate(REMOTE_NAME_PREFIX+id, true, extra_template,\n false)\n\n if OpenNebula.is_error?(rc)\n STDERR.puts(rc.to_str)\n exit(-1)\n end\n\n deploy_id = \"#{DEPLOY_ID_PREFIX}#{rc}\"\n vm = get_remote_vm(deploy_id)\n\n if !context_str.nil?\n new_context_update = 'CONTEXT = [' << context_str << ']'\n new_context_update = new_context_update.gsub(\"\\n\", \",\\n\")\n rc = vm.updateconf(new_context_update)\n end\n\n if OpenNebula.is_error?(rc)\n STDERR.puts(rc.to_str)\n exit(-1)\n end\n\n vm.release\n\n rc = vm.update(\"REMOTE_OPENNEBULA_DEPLOY_ID = \\\"#{deploy_id}\\\"\",\n true)\n\n if OpenNebula.is_error?(rc)\n STDERR.puts('Error adding REMOTE_OPENNEBULA_DEPLOY_ID ' \\\n \"attribute to VM #{rc}: #{rc.to_str}\")\n end\n\n puts(deploy_id)\n else\n restore(deploy_id)\n deploy_id\n end\n end",
"def run_hook(_resources)\n setup_code_deploy_s3_buckets\n end",
"def install\n # nothing to do\n end",
"def init_repo\n return if check_deploy_dir\n FileUtils.mkdir_p @deploy_dir\n FileUtils.cd @deploy_dir do\n if Dir[@deploy_dir+'/*'].empty?\n\n # initialize the repository and add the remote.\n #\n `git init`\n `git remote add #{@remote} #{@repo}`\n\n # Attempt to pull from the remote.\n #\n if git_pull\n `git branch -m #{@branch}`\n\n # If no branch exists on remote, create one locally.\n else\n `echo \"initialize deploy repo\" > _`\n `git add .`\n `git commit -m \\\"initial commit\\\"`\n `git branch -m #{@branch}`\n `git rm _`\n `git add -u`\n `git commit -m 'cleanup'`\n end\n end\n end\n end",
"def release\n diagnostic_file = File.join JONAS_ROOT, \"diagnostics\", 'launch_jonas_diags.rb'\n diagnostics_cmd = \"ruby #{diagnostic_file}\"\n app_war_file = File.join JONAS_BASE, 'deploy' , 'app.war'\n if_jonas_base_exists_string = \"(if test ! -d #{app_war_file} ; then\"\n java_home_string = \"JAVA_HOME=#{@java_home}\"\n java_opts_string = \"JAVA_OPTS=\\\"#{ContainerUtils.to_java_opts_s(@java_opts)}\\\"\"\n export_base_vars_string = 'export JAVA_HOME JAVA_OPTS'\n export_deployme_vars_string = 'export JONAS_ROOT JONAS_BASE'\n deployme_var_string = \"JONAS_ROOT=#{JONAS_ROOT} JONAS_BASE=#{JONAS_BASE}\"\n deployme_root = File.join JONAS_ROOT, 'deployme'\n topology_xml_erb_file = File.join deployme_root, 'topology.xml.erb'\n topology_xml_file = File.join deployme_root, 'topology.xml'\n deployme_jar_file = File.join deployme_root, 'deployme.jar'\n topology_erb_cmd_string = \"erb #{topology_xml_erb_file} > #{topology_xml_file}\"\n deployme_cmd_string = \"$JAVA_HOME/bin/java -jar #{deployme_jar_file} -topologyFile=#{topology_xml_file} -domainName=singleDomain -serverName=singleServerName\"\n else_skip_string = 'else echo \"skipping jonas_base config as already present\"; fi)'\n setenv_cmd_string = File.join JONAS_BASE, 'setenv'\n copyapp_cmd = \"mkdir -p #{app_war_file} && cp -r --dereference * #{app_war_file}/\"\n start_script_string = \"source #{setenv_cmd_string} && jonas start -fg\"\n\n \"(#{diagnostics_cmd} & ); #{java_home_string} #{java_opts_string} && #{export_base_vars_string} && #{if_jonas_base_exists_string} #{deployme_var_string} && #{export_deployme_vars_string} && #{topology_erb_cmd_string} && #{deployme_cmd_string} && #{copyapp_cmd}; #{else_skip_string} && #{start_script_string}\"\n end",
"def before_deploy_site \n Dir.chdir Origen.root do \n system \"origen examples -c\" \n dir = \"#{Origen.root}/web/output/coverage\" \n FileUtils.remove_dir(dir, true) if File.exists?(dir) \n system \"mv #{Origen.root}/coverage #{dir}\" \n end \n end",
"def post_install; end",
"def install\n end",
"def register_as_deployed\n AddCommand.exec \"#{self.name}:#{self.root_path}\", 'servers' => [@shell]\n end",
"def pre_build\n puts \"pre_build dir=#{`pwd`}\"\n rbvt = RUBY_V\n rbvm = RUBY_V[/^\\d+\\.\\d+/]\n # remove leftovers from previous rake.\n rm_rf \"#{TGT_DIR}/lib\"\n rm_rf \"#{TGT_DIR}/etc\"\n rm_rf \"#{TGT_DIR}/share\"\n rm_rf \"#{TGT_DIR}/conf.d\"\n mkdir_p \"#{TGT_DIR}/lib\"\n cp_r \"#{EXT_RUBY}/lib/ruby\", \"#{TGT_DIR}/lib\"\n # copy include files\n mkdir_p \"#{TGT_DIR}/lib/ruby/include/ruby-#{rbvt}\"\n cp_r \"#{EXT_RUBY}/include/ruby-#{rbvt}/\", \"#{TGT_DIR}/lib/ruby/include\"\n SOLOCS.each_value do |path|\n cp \"#{path}\", \"#{TGT_DIR}\"\n end\n # do some windows things\n mkdir_p \"#{TGT_DIR}/share/glib-2.0/schemas\"\n if APP['GTK'] == \"gtk+-2.0\" \n cp_r\"#{TGT_SYS_DIR}/share/glib-2.0/schemas/gschema.dtd\",\n \"#{TGT_DIR}/share/glib-2.0/schemas\"\n cp_r \"#{ShoesDeps}/share/fontconfig\", \"#{TGT_DIR}/share\"\n cp_r \"#{ShoesDeps}/share/themes\", \"#{TGT_DIR}/share\"\n cp_r \"#{ShoesDeps}/share/xml\", \"#{TGT_DIR}/share\"\n cp_r \"#{ShoesDeps}/share/icons\", \"#{TGT_DIR}/share\"\n elsif APP['GTK'] == \"gtk+-3.0\"\n cp \"#{TGT_SYS_DIR}share/glib-2.0/schemas/gschemas.compiled\" ,\n \"#{TGT_DIR}/share/glib-2.0/schemas\"\n cp_r \"#{ShoesDeps}/share/fontconfig\", \"#{TGT_DIR}/share\"\n cp_r \"#{ShoesDeps}/share/themes\", \"#{TGT_DIR}/share\"\n cp_r \"#{ShoesDeps}/share/xml\", \"#{TGT_DIR}/share\"\n cp_r \"#{ShoesDeps}/share/icons\", \"#{TGT_DIR}/share\"\n else\n cp \"#{TGT_SYS_DIR}share/glib-2.0/schemas/gschemas.compiled\" ,\n \"#{TGT_DIR}/share/glib-2.0/schemas\"\n end\n sh \"#{WINDRES} -I. shoes/appwin32.rc shoes/appwin32.o\"\n cp_r \"#{ShoesDeps}/etc\", TGT_DIR\n mkdir_p \"#{ShoesDeps}/lib\"\n if APP['GTK'] == \"gtk+-3.0\"\n cp_r \"#{ShoesDeps}/lib/gtk-3.0\", \"#{TGT_DIR}/lib\" # shoes, exerb, ruby here\n else\n cp_r \"#{ShoesDeps}/lib/gtk-2.0\", \"#{TGT_DIR}/lib\" # shoes, exerb, ruby here\n end\n bindir = \"#{ShoesDeps}/bin\"\n #cp_r \"#{bindir}/fc-cache.exe\", TGT_DIR\n cp_r \"#{bindir}/gtk-update-icon-cache.exe\", TGT_DIR\n # below for debugging purposes\n if ENV['GDB'] \n cp \"#{bindir}/fc-cat.exe\", TGT_DIR\n cp \"#{bindir}/fc-list.exe\", TGT_DIR\n cp \"#{bindir}/fc-match.exe\", TGT_DIR\n cp \"#{bindir}/fc-pattern.exe\", TGT_DIR\n cp \"#{bindir}/fc-query.exe\", TGT_DIR\n cp \"#{bindir}/fc-scan.exe\", TGT_DIR\n cp \"#{bindir}/fc-validate.exe\", TGT_DIR\n end\n # disable MS Theme\n if !ENABLE_MS_THEME \n Dir.chdir(\"#{TGT_DIR}/share/themes/MS-Windows/gtk-2.0/\") do\n mv 'gtkrc', 'disabled-gtkrc'\n end\n else\n # add our overrides to the MS-Windows theme\n cp \"platform/msw/gtkrc\", \"#{TGT_DIR}/etc/gtk-2.0/\"\n end\n end",
"def prepare_deploy(t, args)\n set_verbosity(args)\n\n plugins_dir = Pathname.new(\"#{args.plugin_dir || '/var/tmp/bundles/plugins/ruby'}\").expand_path\n mkdir_p plugins_dir, :verbose => @verbose\n\n plugin_path = plugin_path(plugins_dir, false) # \"#{plugins_dir}/#{name}\"\n if plugin_path.exist?\n if args.force == \"true\"\n safe_unlink plugin_path # if link (deploy:dev) just remove the link\n if plugin_path.exist?\n @logger.info \"Deleting previous plugin deployment #{plugin_path}\"\n rm_rf plugin_path, :verbose => @verbose if plugin_path.exist?\n else\n @logger.info \"Unlinked previous plugin deployment #{plugin_path}\"\n end\n else\n raise \"Cowardly not deleting previous plugin deployment #{plugin_path} - override with rake #{t.name}[true]\"\n end\n end\n plugins_dir\n end",
"def create_project(tx)\n Installer.copy(tx, \"#{@service_dir}/pieces/public\", get_path(:web))\n true\n end",
"def action_create\n\n install_prerequisites\n\n node.set['pedant'][new_resource.variant]['etc_dir'] = new_resource.config_dir\n\n directory new_resource.config_dir do\n owner new_resource.user\n group new_resource.group\n mode \"0755\"\n recursive true\n end\n\n source_dir = \"#{new_resource.checkout_dir}/#{new_resource.variant}\"\n\n git new_resource.variant do\n destination source_dir\n repository \"git@github.com:opscode/#{new_resource.variant}.git\"\n revision new_resource.revision\n user new_resource.git_user\n end\n\n node.set['pedant'][new_resource.variant]['dir'] = \"/srv/#{new_resource.variant}\"\n\n link node['pedant'][new_resource.variant]['dir'] do\n to source_dir\n end\n\n template \"#{new_resource.config_dir}/pedant_config.rb\" do\n source new_resource.config_template\n owner new_resource.user\n group new_resource.group\n mode \"0644\"\n variables(new_resource.variables)\n end\n\n execute \"bundle install\" do\n cwd node['pedant'][new_resource.variant]['dir']\n # user \"opscode\"\n end\n\nend",
"def install\n invoke \"totem:lodestar:install:javascripts\"\n invoke \"totem:lodestar:install:stylesheets\"\n invoke \"totem:lodestar:install:images\"\n invoke \"totem:lodestar:install:configs\", [file_name]\n invoke \"totem:lodestar:install:databases\", [file_name]\n invoke \"totem:lodestar:install:routes\"\n invoke \"totem:lodestar:install:documents\"\n invoke \"totem:lodestar:install:travis_ci\", [file_name]\n invoke \"totem:lodestar:install:views\", [file_name]\n end",
"def install(env); end",
"def after_release_email(tag, note, type, selector, options) \n command = \"origen web compile --remote --api\" \n Dir.chdir Origen.root do \n system command \n end \n end",
"def compile\n download_jonas\n download_deployme\n remove_jcl_over_slf\n puts 'Compile completed, release cmd to be run:'\n puts release\n end",
"def prepare_common_installation\n `cd #{self.project_root} && BUNDLE_GEMFILE=Gemfile bundle exec cap #{self.environment} deploy:prepare_installation:common -S phase=node_prepare HOSTS=#{self.hostname}`\n end",
"def deploy\n\n $active_deploy = true\n bucket = JSON.parse($deploy_bucket.last.to_json)\n unless bucket.nil?\n puts \"Deploying code for: #{bucket.inspect}\"\n system(\"./deploy.sh #{bucket['git_account']} #{bucket['launch_branch_name']} #{bucket['git_appname']} #{bucket['heroku_appname']} #{bucket['folder_name']}\")\n end\n $deploy_bucket.pop\n puts \"Now making active_deploy as false\"\n $active_deploy = false\n check_build bucket\nend",
"def deploy_local(appdir, appname, params={})\n @vespa.deploy_local(appdir, appname, @vespa.nodeproxies[hostlist.first], selfdir, params)\n end",
"def stage_wp_site\n # Note - this assumes that the wordpress files are saved in the repository that\n # the WPDeploy script will look for them in a particular directory\n begin \n if AppConfig.wp_deploy_enabled?\n LOGGER.debug \"Staging original wordpress site for project #{self.label}\"\n wpd = WpDeploy.new(self.label)\n wpd.deploy\n else\n LOGGER.info \"Skipping staging of WordPress site for #{self.label} as wp_deploy is disabled\"\n end\n rescue Exception => e\n LOGGER.error \"Error occurred staging original wordpress site: #{e.message}\"\n end\n end",
"def execute!\n config = instantiate_configuration\n config.logger.level = options[:verbose]\n config.load 'deploy'\n\n status = catch(:abort_called_by_capistrano){\n set_webistrano_logger(config)\n \n set_up_config(config)\n \n exchange_real_revision(config) unless (config.fetch(:scm).to_s == 'git') # git cannot do a local query by default\n save_revision(config)\n save_pid\n \n config.trigger(:load)\n execute_requested_actions(config)\n config.trigger(:exit)\n }\n \n if status == :capistrano_abort\n false\n else\n config\n end\n rescue Exception => error\n handle_error(error) \n return false\n end",
"def install\n # Delayed so that Rake doesn't need to be loaded to run this file.\n extend ::Rake::DSL\n\n # Rename the original release task.\n release_task = ::Rake.application.lookup('release')\n if release_task\n release_actions = release_task.actions.dup\n task 'release:original' => release_task.prerequisites.dup do\n release_actions.map(&:call)\n end\n release_task.clear\n end\n\n # No-op Bundler's release:source_control_push task.\n source_control_push_task = ::Rake.application.lookup('release:source_control_push')\n source_control_push_task.clear if source_control_push_task\n\n # Tag the release.\n task 'release:tag' do\n tag_release!(commit: false)\n end\n\n # Make the new release tasks.\n desc \"Bump, tag, and release #{gem_name}\"\n task 'release' do\n release_gem!(:patch)\n end\n\n desc \"Bump minor, tag, and release #{gem_name}\"\n task 'release:minor' do\n release_gem!(:minor)\n end\n\n desc \"Bump major, tag, and release #{gem_name}\"\n task 'release:major' do\n release_gem!(:major)\n end\n end",
"def init\n webby_ip, host = *options\n host = app_name unless host\n\n unless file_exists(\".pushand\")\n log \"Initializing deployment descriptor for #{host}...\"\n create_file \".pushand\", \"#! /bin/bash\\nphd $0 #{host}\\n\"\n run \"chmod +x .pushand\"\n end\n\n unless file_exists(\".gitignore\")\n log \"Creating .gitignore file...\"\n create_file \".gitignore\", File.open(File.join(templates_path, 'gitignore')).read\n end\n\n if dir_exists(\".git\")\n log \"Adding Webbynode remote host to git...\"\n else\n log \"Initializing git repository...\"\n end\n\n # @ Felipe\n #\n # Now also passes the host to the git_init method\n # Notice how I replaced the \"git remote add webbynode git@#{ip}:{app_name}\"\n # to \"git remote add webbynode git@#{ip}:{HOST}\"\n #\n # Is this a good idea? The reason I did this is because when you execute\n # webbynode remote 'ls -la' to read out the directory, it parses the .pushand file to\n # fetch the [host]. However, what apparently happens is that the folder on the remote server\n # would always be named after the folder on the local machine (app_name) in this case.\n # So I changed this app_name to host inside the git_init method so that if you for example execute:\n #\n # webbynode init 2.2.2.2 dev.webbynode.com\n #\n # It will create for example: /var/rails/dev.webbynode.com, which, also is in my opinion better than just webbynode\n # because if you want to have subdomains (such as that dev. (development) subdomain, it's more clear as to what is the main and what is the subdomain)\n #\n # One problem (which should be easy to solve but I think it's serverside) is that it apparently attempts to create a user for the MySQL and PostgreSQL database.\n # And as we both know it will most likely fail when it creates a user with the username: dev.webbynode.com instead. I deployed an app, and this seemed to be the case.\n # It failed to create a database and migrate it because it couldn't find the user, which most likely cannot be created due to the name I think. So I changed it to root\n # manually inside the config/database.yml and it worked again.\n #\n # What do you think?\n #\n # Here is an example of what got rendered as database.yml on my Webby\n #\n # # inside: /var/rails/test.wizardry-ls.com/config/database.yml\n # production:\n # adapter: mysql\n # encoding: utf8\n # database: test.wizardry-ls.com # <= Will fail\n # username: test.wizardry-ls.com # <= Will fail\n # password: mypassword\n #\n # I think we should always strip out \"any\" characters for the database.yml that aren't characters/digits. So that you end up always having alphanumeric.\n # The only issue is the database.yml on this part as far as I can see. If we can fix it so it will remove any non [a-zA-z0-9] characters then it should work\n # right out of the box.\n #\n git_init(webby_ip, host)\n end",
"def run_all\n deploy_code\n run_test\n end",
"def setup\n\n setup_path\n save_application_details\n add_jvm_args\n rename_server_instance\n\n \"/bin/sh ./#{SETUP_ENV_SCRIPT}\"\n end",
"def deploy()\n return Error.new('ID not defined') unless @id\n \n node_types().each do |node_type|\n node_type.set_action(\"DEPLOY\")\n end\n end",
"def setup_before_restart\n tcs_static = node['thecollegesound']['static_root']\n tcs_app = File.join(node['thecollegesound']['app_root'], 'current')\n\n # -- Link statics (css, js, basic images)\n # FIXME: Consolidate the image directories\n ['css', 'js', 'images', 'icons', 'img'].each do |dir|\n link \"#{tcs_static}/static/#{dir}\" do\n to \"#{tcs_app}/collegesound/static/#{dir}\"\n end\n end\n\n # -- Link templates\n link \"#{tcs_static}/templates\" do\n to \"#{tcs_app}/collegesound/templates\"\n end\n\n # -- Install the package\n bash 'install_package' do\n user 'root'\n cwd tcs_app\n code 'python setup.py install'\n end\n\n # -- Run migration\n bash 'run_migration' do\n user 'root'\n cwd \"#{tcs_app}/collegesound\"\n code <<-EOH\n python manage.py convert_to_south main\n python manage.py migrate main\n EOH\n end\nend",
"def push\n if File.exist?(@local)\n check_branch\n init_repo\n puts \"Syncing #{@local.sub(Dir.pwd.strip+'/', '')} files to #{@repo}.\"\n FileUtils.cd @deploy_dir do\n git_pull\n clean_deploy\n copy_site\n git_push\n end\n else\n abort \"Cannot find site build at #{@local}. Be sure to build your site first.\"\n end\n end",
"def deploy\n\t# This task is typiclly run after the site is updated but before the server is restarted.\n\tcall 'migrate'\nend",
"def pre_perform!\n return unless perform_hooks?\n unless hooks.pre_hooks.any?\n GitPusshuTen::Log.message \"No pre deploy hooks to perform.\"\n return\n end\n \n ##\n # Connect to the remote environment and perform the pre deploy hooks\n hooks.render_commands(hooks.pre_hooks).each do |name, commands|\n adjusted_name = name.sub(/^\\d+\\)\\s/, '')\n \n GitPusshuTen::Log.message(\"Performing pre deploy hook: #{y(adjusted_name)}\")\n standard environment.execute_as_user(\"cd '#{e.app_dir}'; #{commands}\")\n end\n end",
"def install_app\n STDERR.puts \"Installing #{@name} from #{@source} into #{target}\"\n dirs = Dir.entries(@source)\n use_engine = dirs.include?(\"crowbar_engine\")\n dirs.sort.each do |ent|\n next if /^\\./ =~ ent or ent == \"debian\"\n case ent\n when \"crowbar_framework\"\n next if use_engine || skip_files\n debug(\"Copying crowbar_framework files over for #{@name}\")\n FileUtils.cp_r(File.join(@source,'crowbar_framework'),target)\n when \"crowbar_engine\"\n FileUtils.cp_r(File.join(@source,ent),dir) unless @source == dir\n if FileTest.exists?(File.join(dir,ent,\"barclamp_\"+@name+\"/test/unit\"))\n FileUtils.mkdir_p(File.join(target,\"crowbar_framework/test/unit\"))\n FileUtils.cp_r(File.join(dir,ent,\"barclamp_\"+@name+\"/test/unit\"),File.join(target,\"crowbar_framework/test/\"))\n end\n if FileTest.exists?(File.join(dir,ent,\"barclamp_\"+@name+\"/test/\"+@name+\"_test_helper.rb\"))\n FileUtils.cp(File.join(dir,ent,\"barclamp_\"+@name+\"/test/\"+@name+\"_test_helper.rb\"),File.join(target,\"crowbar_framework/test/\"))\n end\n debug(\"#{@name} is implemented using a Rails Engine.\")\n debug(\"Linking in routes and Gemfile entries.\")\n gem_name = \"barclamp_#{@name}\"\n engine_class = \"Barclamp%s::Engine\" % camelize(@name)\n # N.B. the run-time path to the engine could be different from\n # the install-time path referenced by our 'dir' variable, so\n # instead we use a 'crowbar_path' variable set at runtime by\n # the main Gemfile.\n engine_path = File.join('crowbar_engine', gem_name)\n framework_dir = File.join(target, 'crowbar_framework')\n routes_dir = File.join(framework_dir, 'config', 'routes.d')\n gemfile_dir = File.join(framework_dir, 'Gemfile.d')\n FileUtils.mkdir_p(routes_dir)\n FileUtils.mkdir_p(gemfile_dir)\n routes_plugin = File.join(routes_dir, \"barclamp-#{@name}-engine.routes\")\n gemfile_plugin = File.join(gemfile_dir, \"barclamp-#{@name}.gemfile\")\n File.open(routes_plugin, 'w') do |f|\n f.puts(\"mount #{engine_class}, :at => '#{@name}'\")\n end unless File.exists?(routes_plugin)\n File.open(gemfile_plugin, 'w') do |f|\n f.puts(\"gem '#{gem_name}', :path => File.join(crowbar_path, '..', 'barclamps', '#{@name}', '#{engine_path}')\")\n end unless File.exists?(gemfile_plugin)\n when 'bin'\n debug(\"Installing commands for #{@name}\")\n FileUtils.mkdir_p(File.join(target,'bin'))\n FileUtils.cp_r(File.join(@source,'bin'),target)\n FileUtils.chmod_R(0755,File.join(target,'bin'))\n when 'etc'\n debug(\"Installing configs for #{@name}\")\n FileUtils.mkdir_p(File.join(@root,'etc'))\n FileUtils.cp_r(File.join(@source,'etc'),@root)\n when 'updates'\n debug(\"Installing Sledgehammer updates for #{@name}\")\n FileUtils.mkdir_p(File.join(@root,'updates'))\n FileUtils.cp_r(File.join(@source,'updates'),@root)\n when 'BDD'\n debug(\"Installing BDD framework components for #{@name}\")\n FileUtils.mkdir_p(File.join(target,'BDD'))\n FileUtils.cp_r(File.join(@source,'BDD'),target)\n when 'doc'\n debug(\"Installing documentation for #{@name}\")\n FileUtils.mkdir_p(File.join(target,'doc',@name))\n FileUtils.cp_r(File.join(@source,'doc','.'),File.join(target,'doc',@name))\n else\n next if @source == dir\n debug(\"Copying #{ent} into #{dir}\")\n FileUtils.mkdir_p(dir)\n FileUtils.cp_r(File.join(@source,ent),dir)\n end\n end\n end",
"def install\n nil\n end",
"def setup\n @executor.start_section \"Vundle\"\n @executor.create_path_in_home \".vim\", \"bundle\", \"vundle\"\n @executor.execute \"Cloning Vundle\", \"git clone #{@vundle_repo} #{vundle_folder}\" do |output, error_output|\n raise TaskSkipped.new(\"Already exists\") if error_output.include? \"already exists\"\n end\n end",
"def compile\n system \"rm -rf #{new_relic_home}\"\n system \"mkdir -p #{new_relic_home}\"\n system \"mkdir -p #{File.join new_relic_home, 'logs'}\"\n\n JavaBuildpack::Util.download(@version, @uri, 'New Relic Agent', jar_name(@version), new_relic_home)\n copy_resources new_relic_home\n end",
"def run!\n project.mode = :release\n\n # Validate paths\n validate_paths!\n\n # Extract mockup\n copy_source_path_to_build_path!\n\n validate_stack!\n\n # Run stack\n run_stack!\n\n # Cleanup\n cleanup! if config[:cleanup_build]\n ensure\n project.mode = nil\n end",
"def setup_skeleton\r\n self.destination_root = File.join(path, name)\r\n @class_name = name.classify\r\n @guid = UUIDTools::UUID.timestamp_create.to_s\r\n directory(\"base_app/\", self.destination_root)\r\n copy_file File.join(self.destination_root, \"blend_solution.sln\"), File.join(self.destination_root, \"#{@class_name}.sln\")\r\n copy_file File.join(self.destination_root, \"src\", \"ironnails_controls.csproj\"), File.join(self.destination_root, \"src\", \"#{@class_name}.Controls.csproj\")\r\n remove_file File.join(self.destination_root, \"blend_solution.sln\")\r\n remove_file File.join(self.destination_root, \"src\", \"ironnails_controls.csproj\")\r\n\r\n store_component_config('.components')\r\n end",
"def deploy(id, host, remote_dfile, not_used)\n local_dfile = get_local_deployment_file(remote_dfile)\n\n if !local_dfile || File.zero?(local_dfile)\n send_message(ACTION[:deploy],RESULT[:failure],id,\n \"Can not open deployment file #{local_dfile}\")\n return\n end\n \n local_action(\"#{@actions_path}/deploy #{host} #{local_dfile}\",id,:deploy)\n end",
"def action_deploy\n notifying_block do\n write_config\n end\n end",
"def prepare!\n %x[git checkout master]\n unless %x[git status] =~ /nothing to commit \\(working directory clean\\)/\n puts \"Please commit your changes on the master branch before deploying!\"\n exit 1\n end\n\n puts \"Creating and moving in to \\\"deployment\\\" branch..\"\n puts %x[git checkout -b deployment]\n\n puts \"Removing \\\"output\\\" directory from .gitignore..\"\n gitignore = File.read(\".gitignore\")\n File.open(\".gitignore\", \"w\") do |file|\n file.write(gitignore.gsub(\"output\", \"\"))\n end\n\n change_base_url_to(BASE_URL)\nend",
"def prepare!\n %x[git checkout master]\n unless %x[git status] =~ /nothing to commit \\(working directory clean\\)/\n puts \"Please commit your changes on the master branch before deploying!\"\n exit 1\n end\n\n puts \"Creating and moving in to \\\"deployment\\\" branch..\"\n puts %x[git checkout -b deployment]\n\n puts \"Removing \\\"output\\\" directory from .gitignore..\"\n gitignore = File.read(\".gitignore\")\n File.open(\".gitignore\", \"w\") do |file|\n file.write(gitignore.gsub(\"output\", \"\"))\n end\n\n change_base_url_to(BASE_URL)\nend",
"def prepare!\n %x[git checkout master]\n unless %x[git status] =~ /nothing to commit \\(working directory clean\\)/\n puts \"Please commit your changes on the master branch before deploying!\"\n exit 1\n end\n\n puts \"Creating and moving in to \\\"deployment\\\" branch..\"\n puts %x[git checkout -b deployment]\n\n puts \"Removing \\\"output\\\" directory from .gitignore..\"\n gitignore = File.read(\".gitignore\")\n File.open(\".gitignore\", \"w\") do |file|\n file.write(gitignore.gsub(\"output\", \"\"))\n end\n\n change_base_url_to(BASE_URL)\nend",
"def setup\n Athenry::setup.target(\"fetchstage\", \"extractstage\", \"fetchsnapshot\", \"updatesnapshot\", \"copysnapshot\", \"copy_scripts\", \"copy_configs\")\n end",
"def deploy_to_cloud(project_config: {}, cloud_config: {}, local_image_name: '')\n puts \"#{__method__.to_s} enter\"\n\n cloud_info = push_container_image_to_cloud(\n cloud_config: cloud_config,\n local_image_name: local_image_name,\n )\n\n\n kubernetes(\n uber_name: project_config.name,\n keys: project_config.keys,\n remote_image_uri: cloud_info.remote_registry_image_uri\n )\n\n puts \"#{__method__.to_s} exit\"\nend",
"def publish!\n inform \"Publishing local version to http://chapmanu.github.io/web-components\"\n \n # Production Configuration\n inform \"Building site with production configuration\"\n Jekyll::Site.new(Jekyll.configuration({\n \"source\" => \".\",\n \"destination\" => \"_site\"\n })).process\n\n Dir.mktmpdir do |tmp|\n FileUtils.cp_r \"_site/.\", tmp\n \n pwd = Dir.pwd\n Dir.chdir tmp\n\n cmd \"git init\"\n cmd \"git add .\"\n message = \"Site updated at #{Time.now.utc}\"\n cmd \"git commit -m #{message.inspect}\"\n cmd \"git remote add origin git@github.com:#{GITHUB_REPONAME}.git\"\n cmd \"git push origin master:refs/heads/gh-pages --force\"\n\n Dir.chdir pwd\n end\n inform \"Publish successful\"\n end",
"def project; end",
"def action_deploy\n notifying_block do\n directory new_resource.path do\n owner new_resource.owner\n group new_resource.group\n mode '755'\n end\n end\n end",
"def post_install\n end"
] |
[
"0.69879",
"0.69847274",
"0.6892983",
"0.6831968",
"0.68097377",
"0.68072814",
"0.67954785",
"0.6778892",
"0.67502743",
"0.67266977",
"0.6706492",
"0.6660971",
"0.66427404",
"0.65669",
"0.6535593",
"0.651196",
"0.65044767",
"0.64739376",
"0.64739376",
"0.64305824",
"0.6387655",
"0.6383724",
"0.6364832",
"0.63612485",
"0.63517064",
"0.6334874",
"0.6320194",
"0.6320194",
"0.6304666",
"0.62868786",
"0.62815934",
"0.6226784",
"0.6223414",
"0.6216475",
"0.6215081",
"0.6203481",
"0.617698",
"0.6169777",
"0.6163033",
"0.6153554",
"0.6153475",
"0.61389154",
"0.61362135",
"0.61129904",
"0.608914",
"0.6076959",
"0.6065149",
"0.6061061",
"0.60580367",
"0.6044312",
"0.6034883",
"0.6031146",
"0.60276157",
"0.60206825",
"0.60138583",
"0.5998861",
"0.59936076",
"0.59766525",
"0.59654176",
"0.5963515",
"0.5958317",
"0.5954839",
"0.59505665",
"0.5941769",
"0.5937562",
"0.5935116",
"0.59285283",
"0.59038544",
"0.590334",
"0.5900324",
"0.58971226",
"0.5894848",
"0.5893997",
"0.5889382",
"0.58802986",
"0.58556587",
"0.5855275",
"0.58529884",
"0.5851812",
"0.58445066",
"0.5839888",
"0.5836361",
"0.5835507",
"0.5824761",
"0.58243066",
"0.5822028",
"0.58209944",
"0.5810692",
"0.5803996",
"0.5798435",
"0.57916254",
"0.5789623",
"0.5789623",
"0.5789623",
"0.5788159",
"0.5782866",
"0.57811475",
"0.5779056",
"0.577091",
"0.5764861"
] |
0.6962579
|
2
|
:nodoc: A string representation of this Version.
|
def version
@version.dup
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def to_s\n self.version.to_s\n end",
"def to_s\n @version\n end",
"def to_s\n @version\n end",
"def to_s\n \"<Version #{number}>\"\n end",
"def to_s\n @version\n end",
"def to_s\n version = get_version_string\n version << \"-#{get_pre_string}\" unless @pre == nil\n version << \"+#{get_build_string}\" unless @build == nil\n version\n end",
"def to_s\n \"#{output}\\n[#{version}]\"\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def inspect\n\t\t\trval = super\n\t\t\treturn rval unless self.structure_version\n\t\t\tvstring = \"%d.%d\" % [ self.structure_version, self.data_version ]\n\t\t\treturn rval.sub( />$/, \"; version: #{vstring}>\" )\n\t\tend",
"def to_s\n self.inspect\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n @string\n end",
"def to_s\n getUIversion.to_s\n end",
"def to_s\n toString()\n end",
"def to_s\n getUIversion().to_s\n end",
"def to_s\n getUIversion().to_s\n end",
"def to_s\n getUIversion().to_s\n end",
"def to_s\n getUIversion().to_s\n end",
"def to_s\n getUIversion().to_s\n end",
"def to_s\n\t\tgetUIversion().to_s\n\tend",
"def to_s\n\t\tgetUIversion().to_s\n\tend",
"def to_s\n\t\t\t@string\n\t\tend",
"def to_s()\n #This is a stub, used for indexing\n end",
"def to_s\n return self.get_info()\n end",
"def to_s\n stringify\n end",
"def to_s\n toString\n end",
"def to_s\n return \"#{namespace}:#{project}:#{component}:#{version}\"\n end",
"def to_s\n self\n end",
"def to_s\n @string ||= Builder::ToString.new(self).string\n end",
"def toString\n #Not sure if we want this or just use the getters for more\n #selective formatting\n end",
"def to_s\n @@version ||= [ MAJOR, MINOR, PATCH ] * '.'\n end",
"def versionString()\n\t\t\t\treturn \"#{major}.#{minor}.#{build}\"\n\t\t\tend",
"def to_s\n string\n end",
"def to_s\n\t\trval = \"%s=%s\" % [ self.name, self.make_valuestring ]\n\n\t\trval << make_field( \"Version\", self.version ) if self.version.nonzero?\n\t\trval << make_field( \"Domain\", self.domain )\n\t\trval << make_field( \"Expires\", make_cookiedate(self.expires) ) if self.expires\n\t\trval << make_field( \"Max-Age\", self.max_age )\n\t\trval << make_field( \"Path\", self.path )\n\n\t\trval << '; ' << 'HttpOnly' if self.httponly?\n\t\trval << '; ' << 'Secure' if self.secure?\n\n\t\treturn rval\n\tend",
"def to_s\n full\n end",
"def to_s\n to_h.to_s\n end",
"def to_s\n @str\n end",
"def to_s\n @str\n end",
"def to_s\n s = []\n s << \"#{title} v#{version}\"\n s << \"\"\n s << \"#{summary}\"\n s << \"\"\n s << \"contact : #{contact}\"\n s << \"homepage : #{homepage}\"\n s << \"repository : #{repository}\"\n s << \"authors : #{authors.join(',')}\"\n s << \"package : #{name}-#{version}\"\n s << \"requires : #{requires.join(',')}\"\n s.join(\"\\n\")\n end",
"def version\n super.to_s\n end",
"def version\n super.to_s\n end",
"def to_s\n inspect\n end",
"def version\n build_string\n end",
"def to_s\n \"#{path} | #{native_revision_identifier}\"\n end",
"def to_s\n Formatter::ToString.format(self)\n end",
"def to_s\n self.api_version\n end",
"def to_s\n\t\tparts = [ self.oid ]\n\n\t\tparts << \"NAME %s\" % Treequel::Schema.qdescrs( self.names ) unless self.names.empty?\n\n\t\tparts << \"DESC '%s'\" % [ self.desc ] if self.desc\n\t\tparts << \"OBSOLETE\" if self.obsolete?\n\t\tparts << \"APPLIES %s\" % [ Treequel::Schema.oids(self.attr_oids) ]\n\t\tparts << self.extensions.strip unless self.extensions.empty?\n\n\t\treturn \"( %s )\" % [ parts.join(' ') ]\n\tend",
"def to_s\n raise_on_bad_version_status\n\n str = +''\n str << self.version << ' ' << self.status_code << ' ' << self.status_mesg << \"\\r\\n\"\n str << self[:headers].to_s if self[:headers].given?\n str << self.body\n end",
"def inspect\n \"#{@type} #{@version}\"\n end",
"def to_s()\n\t\t\t\"#{self.class} (#{self.__id__}):\"\n\t\tend",
"def to_s\n return '' if name.nil?\n return name if version.nil?\n return \"#{name}-#{version}\" if arch.nil?\n \"#{name}-#{version}-#{arch}\"\n end",
"def to_s\n self.inspect\n end",
"def to_s\n\t\t\"#{self.name}\"\n\tend",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def inspect\n to_s\n end",
"def to_s\n @value\n end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s() end",
"def to_s\n value\n end",
"def to_s\n value\n end",
"def to_s\n @string.to_s\n end",
"def to_s\n raise NotImplementedError\n end",
"def to_str\n @value\n end",
"def inspect\n self.to_s\n end",
"def inspect\n self.to_s\n end",
"def to_s()\n serialize.to_s()\n end",
"def to_s()\n serialize.to_s()\n end",
"def inspect\n serialize.to_s\n end",
"def to_s\n sprintf '#<%s:%#0x @timestamp: %s @changes: {%d}>',\n self.class.to_s,\n self.object_id,\n @timestamp.strftime('%d/%b/%Y:%H:%M:%S %z'),\n length\n end",
"def to_s\n str\n end",
"def to_s\r\n value.inspect\r\n end",
"def to_s\r\n dump\r\n end",
"def to_s\n '[custom]'\n end",
"def to_s()\n #This is a stub, used for indexing\n end",
"def to_s()\n #This is a stub, used for indexing\n end",
"def to_s()\n #This is a stub, used for indexing\n end",
"def to_s\n return \"#{self.name}\"\n end",
"def to_s\n @value.to_s\n end",
"def to_s\n @value.to_s\n end"
] |
[
"0.8215513",
"0.8058804",
"0.8058804",
"0.796417",
"0.79218316",
"0.760062",
"0.7438801",
"0.74122417",
"0.74122417",
"0.74122417",
"0.74122417",
"0.73941314",
"0.7385345",
"0.7279383",
"0.7279383",
"0.7279383",
"0.7279383",
"0.7270175",
"0.72545546",
"0.7232385",
"0.7232385",
"0.7232385",
"0.7232385",
"0.7232385",
"0.7164362",
"0.7164362",
"0.7145967",
"0.71456707",
"0.71404314",
"0.7139079",
"0.7122299",
"0.71215904",
"0.71209663",
"0.7105512",
"0.70917493",
"0.7076139",
"0.7074499",
"0.7017768",
"0.6986915",
"0.6951287",
"0.6931944",
"0.6915507",
"0.6915507",
"0.68947345",
"0.6879409",
"0.6879409",
"0.68791324",
"0.68719226",
"0.6857936",
"0.683474",
"0.68305224",
"0.68300194",
"0.68176967",
"0.6808765",
"0.67918944",
"0.6787657",
"0.67793244",
"0.6777592",
"0.6772192",
"0.6772192",
"0.67688704",
"0.6763178",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6760963",
"0.6758928",
"0.6758928",
"0.6757621",
"0.67549634",
"0.6750626",
"0.67501396",
"0.67501396",
"0.6745424",
"0.6745424",
"0.6741221",
"0.6732154",
"0.6730199",
"0.6727964",
"0.6723301",
"0.672267",
"0.6722206",
"0.6722206",
"0.6722206",
"0.6718622",
"0.67100835",
"0.67100835"
] |
0.0
|
-1
|
The full version, with extra zeros prepended for minor and patch if they are missing.
|
def full_version
segments = self.segments
segments.push 0 while segments.size < 3
segments.join(".")
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def full_version\n return nil unless exact\n\n \"~> \".concat(version)\n end",
"def version\n @version ||= version_hex.to_s(16).chars.entries.join('.')\n end",
"def minor_version(version = nil)\n version ||= installed_version?\n return \"0.0\" if version.nil?\n\n version.sub(/\\.\\d+$/, '')\n end",
"def major_version(version = nil)\n version ||= installed_version?\n return \"0\" if version.nil?\n\n version.sub(/(\\.\\d+)+$/, '')\n end",
"def to_s\n minor ? \"#{@major}-#{Patch.pad_minor(@minor)}\" : \"#{@major}\"\n end",
"def versionString()\n\t\t\t\treturn \"#{major}.#{minor}.#{build}\"\n\t\t\tend",
"def full\n @version\n end",
"def version_number\n \"#{self.major}.#{self.minor}\"\n end",
"def version\n build_string\n end",
"def version\n [@major_version, @minor_version].join('.')\n end",
"def number\n \"#{@major}.#{@minor}.#{@patch}\"\n end",
"def semantic_version(major: T.unsafe(nil), minor: T.unsafe(nil), patch: T.unsafe(nil)); end",
"def minor_version; end",
"def to_s\n @@version ||= [ MAJOR, MINOR, PATCH ] * '.'\n end",
"def minor_version_default!\n self.minor_version = 0\n end",
"def major_version(full_version)\n full_version.match(/^(\\d+\\.\\d+\\.\\d+)\\.\\d+$/)[1]\n end",
"def version_major_minor\n version.split('.')[0..1].join('.')\n end",
"def ver\n if v = version\n str = +\"#{program_name} #{[v].join('.')}\"\n str << \" (#{v})\" if v = release\n str\n end\n end",
"def test_format_patch\n version = VMLib::Version.new\n assert_equal '0', version.format('%p')\n \n version.patch = 16\n assert_equal '16', version.format('%p')\n end",
"def to_s\n version = get_version_string\n version << \"-#{get_pre_string}\" unless @pre == nil\n version << \"+#{get_build_string}\" unless @build == nil\n version\n end",
"def major_version; end",
"def test_format_major\n version = VMLib::Version.new\n assert_equal '0', version.format('%M')\n \n version.major = 42\n assert_equal '42', version.format('%M')\n end",
"def major_version\n version.match(/(\\d\\.\\d)/)[0] if name.is_a? String\n end",
"def build_version\n @semver.to_s '%M.%m.%p'\n end",
"def version_without_build\n version.split('-')[0]\n end",
"def to_s\n format(\"%d.%d\", @major, @minor)\n end",
"def version\n @gemspec.version || @version_helper.to_s\n end",
"def minor_version_one!\n self.minor_version = 1\n end",
"def major_minor\n # TODO: It would be cool to try <major>.<minor + 1> if possible.\n ver = version_data['serverVersion']\n [ver['major'], ver['minor']]\n .map(&:to_i)\n .map(&:to_s)\n .join('.')\n end",
"def major_version\n @version_helper.major\n end",
"def major_version\n @version_helper.major\n end",
"def major_version\n @version_helper.major\n end",
"def to_s\r\n \"#{@major}.#{@minor}\"\r\n end",
"def write_version(major, minor, patch, build, _options = T.unsafe(nil)); end",
"def minor_version\n @version_helper.minor\n end",
"def minor_version\n @version_helper.minor\n end",
"def minor_version\n @version_helper.minor\n end",
"def xlate_minor_version()\n return MIN_VERSION_XLATES[@minor_version] if (MIN_VERSION_XLATES.has_key?(@minor_version))\n return(@minor_version.to_s) \n end",
"def major(version)\n res = 0\n res = Regexp.last_match(1) if version =~ /^\\s*(\\d+)\\.\\d+\\.\\d+/\n res\n end",
"def to_s\n v = [major, minor, patch].compact.join('.')\n v += \"-#{pre}\" if pre\n v\n end",
"def def_zero major, minor\n def_value major, minor, 0\n end",
"def version\n \"Version: #{VERSION.split[1]} Created on: \" +\n \"#{REVISION_DATE.split[1]} by #{AUTHOR}\"\n end",
"def version\n \"Version: #{VERSION.split[1]} Created on: \" +\n \"#{REVISION_DATE.split[1]} by #{AUTHOR}\"\n end",
"def version\n \"Version: #{VERSION.split[1]} Created on: \" +\n \"#{REVISION_DATE.split[1]} by #{AUTHOR}\"\n end",
"def version\n @version ||= if token.nil? || Array(packages).empty?\n '0.1.0'\n else\n packages.map do |p|\n Gem::Version.new(p['version'])\n end.sort.last.bump.to_s << '.0'\n end\n end",
"def major ; version.major ; end",
"def test_format_minor\n version = VMLib::Version.new\n assert_equal '0', version.format('%m')\n \n version.minor = 13\n assert_equal '13', version.format('%m')\n end",
"def get_version\n\t\tself.dev_stage.blank? ? dev_stage_string = \"\" : dev_stage_string = self.dev_stage + \" \"\n\t\treturn dev_stage_string + self.maj_version.to_s + \".\" + self.min_version.to_s\n\tend",
"def get_version(version)\n \"V#{version.gsub('-','_')}\"\n end",
"def version_number\n @version ||= nil\n end",
"def test_format_build\n version = VMLib::Version.new\n\n # Test that an emtpy build corresponds to an empty string\n version.build = ''\n assert_equal '', version.format('%b')\n\n # Test that a custom build prints exactly as entered\n version.build = '001'\n assert_equal '+001', version.format('%b')\n\n version.build = '20130313144700'\n assert_equal '+20130313144700', version.format('%b')\n\n version.build = 'exp.sha.5114f85'\n assert_equal '+exp.sha.5114f85', version.format('%b')\n end",
"def bump\n parts = parse_parts_from_version_string\n parts.pop while parts.any? { |part| part.alpha? }\n parts.pop if parts.size > 1\n parts[-1] = parts[-1].succ\n self.class.new(parts.join(\".\"))\n end",
"def version\n @version || 0\n end",
"def to_s\n \"#{@major}.#{@minor}.#{@update} Build #{@build}\"\n end",
"def version\n 0\n end",
"def minor(version)\n res = 0\n res = Regexp.last_match(1) if version =~ /^\\s*\\d+\\.(\\d+)\\.\\d+/\n res\n end",
"def sub_version\n \">= \".concat(version.split('.').first(2).join('.'))\n end",
"def version\n '1.5.1.2' # Version number <major>.<minor>.<patch>.<monthly commit>\n end",
"def default_version; end",
"def version\n case @version\n when Module\n \"#{@version::Major}.#{@version::Minor}.#{@version::Release}\"\n when Proc # not sure about this\n @version.call\n when NilClass\n 'unknown'\n else\n @version\n end\n end",
"def version s=nil; @version = s if s; @version end",
"def dump\r\n [\" minor version: #{@minor}\", \" major version: #{@major}\"]\r\n end",
"def version\n @version_helper.to_s\n end",
"def version\n @version_helper.to_s\n end",
"def to_s\n str = [major, minor, patch].compact.join('.')\n str = \"#{str}.#{pre}\" if pre\n str\n end",
"def min_version\n @min_version ||= nil\n end",
"def bump_minor_version; end",
"def major_minor(version)\n version.split('.').map(&:to_i)\n end",
"def API_version(options={})\n return \"#{@major}.#{@minor}\"\n end",
"def def_zeros major_to_minor\n major_to_minor.each_pair do |major,minor_s|\n [*minor_s].each do |minor|\n def_zero major, minor\n end\n end\n end",
"def formatted_version\n self.api_version.presence || DEFAULT_API_VERSION\n end",
"def xlate_major_version()\n return MAJ_VERSION_XLATES[@major_version] if (MAJ_VERSION_XLATES.has_key?(@major_version))\n return(@major_version.to_s) \n end",
"def version\n @version ||= '1.0'\n end",
"def version\n '2.0.7.7' # Version number <major-update>.<minor-update>.<patch-update>.<commit-count>\n end",
"def bump_major_version; end",
"def version\na = unpack\nv = (a[2] & 0xF000).to_s(16)[0].chr.to_i\nreturn v if (1..5).include? v\nreturn nil\nend",
"def package_version\n @semver.to_s '%M.%m.%p%s'\n end",
"def version(version = nil)\n @version = version if version\n @version\n end",
"def default_version\n nil\n end",
"def version=(_arg0); end",
"def version=(_arg0); end",
"def version=(_arg0); end",
"def version=(_arg0); end",
"def version=(_arg0); end",
"def version_const\n \"Version_\" + @__version.upcase.gsub(\".\", \"_\")\n end",
"def binary_version; end",
"def minimum_required_minor_engine_version\n data.minimum_required_minor_engine_version\n end",
"def mysql_modsec_zero_version_comment\n if self =~ /(--|\\/\\*|\\#)/\n delim=$1\n inj = self.gsub(\"#{delim}\", '')\n else\n inj=self\n end\n foo=\"/*!00000#{inj}*/\"\n foo += delim if delim\n return foo\n end",
"def minor_version_default?\n return true if (@minor_version == 0)\n return false\n end",
"def version\n @version ||= create_version\n end",
"def minor=(_arg0); end",
"def show_elf_version\n\t\t\tver_str = \"#{@elf_version}\"\n\t\t\tver_str += \" (current)\" if @elf_version == 1\n\t\t\tputs \" Version: #{ver_str}\"\n\t\tend",
"def hash\n str = [major, minor, patch].map do |str|\n str ? str : \"0\"\n end.join(\".\")\n\n if pre\n str = \"#{str}.#{pre}\"\n end\n\n str.hash\n end",
"def to_s\n @to_s ||= [@major, @minor, @tiny].join(\".\")\n end",
"def revision\n self.major_rev_number.to_s + '.' + self.minor_rev_number.to_s\n end",
"def test_format_prerelease\n version = VMLib::Version.new\n \n # Test that an empty prerelease corresponds to an empty string\n version.prerelease = ''\n assert_equal '', version.format('%r')\n\n # Test that a dev release corresponds to a -# string\n version.prerelease = '0'\n assert_equal '-0', version.format('%r')\n version.prerelease = '1'\n assert_equal '-1', version.format('%r')\n\n # Test that an alpha prerelease corresponds to a -a.# string\n version.prerelease = 'alpha.1'\n assert_equal '-a.1', version.format('%r')\n version.prerelease = 'a.2'\n assert_equal '-a.2', version.format('%r')\n\n # Test that a beta prerelease corresponds to a -b.# string\n version.prerelease = 'beta.3'\n assert_equal '-b.3', version.format('%r')\n version.prerelease = 'b.4'\n assert_equal '-b.4', version.format('%r')\n\n # Test that a rc prerelease corresponds to a -rc.# string\n version.prerelease = 'rc.5'\n assert_equal '-rc.5', version.format('%r')\n\n # Test that a custom prerelease prints as entered\n version.prerelease = 'foo.bar.baz'\n assert_equal '-foo.bar.baz', version.format('%r')\n version.prerelease = '1.2.3.4.5.6.7.8.9.0'\n assert_equal '-1.2.3.4.5.6.7.8.9.0', version.format('%r')\n\n # Verify that numeric fields are stripped of leading zeroes\n version.prerelease = '1.2.3.4.5.6.7.8.9.09'\n assert_equal '-1.2.3.4.5.6.7.8.9.9', version.format('%r')\n\n end",
"def version\n (version_from_class.to_f / 10).to_s\n end",
"def required_version\n normalize_version(@required_version ||= nil)\n end",
"def current_version\n version_number rev\n end",
"def version\n nil\n end"
] |
[
"0.7619811",
"0.7359167",
"0.70975435",
"0.70632404",
"0.7061299",
"0.6984565",
"0.6977209",
"0.6908264",
"0.68629193",
"0.68619186",
"0.683073",
"0.68145174",
"0.67787987",
"0.67596686",
"0.6679284",
"0.66772634",
"0.6652856",
"0.6633099",
"0.6614034",
"0.66041154",
"0.6520046",
"0.6518638",
"0.65130883",
"0.65010625",
"0.64821976",
"0.6463267",
"0.646222",
"0.6441438",
"0.644117",
"0.6419974",
"0.6419974",
"0.6419974",
"0.6403143",
"0.6398357",
"0.63970983",
"0.63970983",
"0.63970983",
"0.63901824",
"0.6363761",
"0.6360461",
"0.63152283",
"0.62987983",
"0.6298393",
"0.6298393",
"0.6297213",
"0.62774146",
"0.6262202",
"0.625056",
"0.62389404",
"0.621533",
"0.6207633",
"0.6205759",
"0.6197839",
"0.6193991",
"0.617126",
"0.6168765",
"0.6160801",
"0.6157043",
"0.61500496",
"0.6144337",
"0.612481",
"0.6124581",
"0.61185783",
"0.61185783",
"0.60971284",
"0.60878676",
"0.6083721",
"0.60766375",
"0.6066458",
"0.6063485",
"0.6051694",
"0.6032348",
"0.602774",
"0.60227805",
"0.60208744",
"0.6020864",
"0.6015206",
"0.6011483",
"0.6007944",
"0.6004912",
"0.6004912",
"0.6004912",
"0.6004912",
"0.6004912",
"0.600441",
"0.5993082",
"0.5992184",
"0.5990012",
"0.5989946",
"0.5988388",
"0.5983186",
"0.5981216",
"0.5978245",
"0.59770906",
"0.5974159",
"0.5967057",
"0.59663934",
"0.59634966",
"0.5956543",
"0.5950862"
] |
0.7133883
|
2
|
Constructs a Version from the +version+ string. A version string is a series of digits or ASCII letters separated by dots.
|
def initialize(version)
unless self.class.correct?(version)
raise ArgumentError, "Malformed version number string #{version}"
end
@version = version.to_s.strip
@segments = nil
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def initialize(version)\n unless self.class.correct?(version)\n raise ArgumentError, \"Malformed version number string #{version}\"\n end\n\n # If version is an empty string convert it to 0\n version = 0 if version.is_a?(String) && version =~ /\\A\\s*\\Z/\n\n @version = version.to_s.strip.gsub(\"-\",\".pre.\")\n @segments = nil\n end",
"def initialize(version)\n @string = version.to_s\n @parsed = parse @string\n end",
"def initialize version\n raise ArgumentError, \"Malformed version number string #{version}\" unless\n self.class.correct?(version)\n\n @version = version.to_s\n @version.strip!\n end",
"def initialize(version)\n raise ArgumentError, \"Malformed version number string #{version}\" unless\n self.class.correct?(version)\n\n self.version = version\n end",
"def initialize(version, name = nil)\n version = version.to_s if version.is_a?(Integer) || version.is_a?(Float)\n raise TypeError, \"version must be a String, Integer or Float, but was a #{version.class}\" unless version.is_a?(String)\n @tokens = version.split(/(\\.|_|[a-z]+)/)\n @tokens.delete_if { |t| t == \".\" || t == \"_\" }\n insert_zeros_before = []\n @tokens.each_index do |i|\n if @tokens[i] =~ /\\A[0-9]+\\Z/\n while @tokens[i] =~ /\\A0[0-9]/ # Remember zeros, but chop them of for now\n insert_zeros_before << i\n @tokens[i] = @tokens[i][1..-1]\n end\n @tokens[i] = @tokens[i].to_i\n end\n end\n insert_zeros_before.each do |i| # Insert zeros again\n @tokens.insert(i, 0)\n end\n @version = version\n @name = name\n end",
"def version_for(version_string)\n Mixlib::Versioning.parse(version_string)\n end",
"def to_version_string(version)\n version = version.to_s\n if version.match(/\\./)\n version\n else\n from_version_code(version).to_s\n end\n end",
"def bump\n parts = parse_parts_from_version_string\n parts.pop while parts.any? { |part| part.alpha? }\n parts.pop if parts.size > 1\n parts[-1] = parts[-1].succ\n self.class.new(parts.join(\".\"))\n end",
"def normalize_version(str)\n default = \"0.0.1\"\n\n if str.nil? or str.empty?\n default\n elsif str.match /^(\\d)+[.](\\d)+[.](\\d)+$/\n str\n elsif str.match /^((\\d)+[.])*(\\d)+$/\n fix_version(str)\n else\n raise VersionError, \"need a valid version number of the form 0.0.0\"\n end\n end",
"def clean_version(version)\n version.gsub!(/\\A(?:version|v)\\s*/i, '') # deletes leading v or version, eg: 'v1.2.3', 'Version 1.2'\n version.gsub!(/[\\r\\n]/, '') # deletes new lines chars\n version.gsub!(/\\s+/, '-') # replaces all spaces by '-'\n version.gsub!(/[\\.]{2,}/, '.') # replaces more than one consecutive dots by one dot, eg: '0..2.1'\n\n version = \"0#{version}\" if version[0] == '.' # adds leading 0 if first char is a dot, eg: '.2.3'\n\n version\n end",
"def get_version(version)\n \"V#{version.gsub('-','_')}\"\n end",
"def deconstruct_version_string(version)\n match = version.match(/^(\\d+)\\.(\\d+)(?:\\.(\\d+))?$/)\n\n # Match should have 4 parts [0] = input string, [1] = major\n # [2] = minor, [3] = patch (possibly blank)\n if match && match.size == 4\n return [match[1].to_i, match[2].to_i, match[3].to_i || 0]\n else\n return nil\n end\n end",
"def v string\n Gem::Version.create string\n end",
"def v string\n Gem::Version.create string\n end",
"def initialize(version)\n case version\n when HTTPVersion\n @major, @minor = version.major, version.minor\n when String\n if /^(\\d+)\\.(\\d+)$/ =~ version\n @major, @minor = $1.to_i, $2.to_i\n end\n end\n if @major.nil? || @minor.nil?\n raise ArgumentError,\n format(\"cannot convert %s into %s\", version.class, self.class)\n end\n end",
"def parse_version_str(version_str)\n version = date_str = certificate_version = ''\n revision = date_time = nil\n if version_str && version_str.length > 0\n if md = version_str.match(/(\\d|\\.)+/)\n version = md[0]\n # date_str\n if md2 = md.post_match.match(/-([\\d]{8}.[\\d]{6})(-|$)/)\n date_str = md2[1]\n d, t = date_str.scan(/\\d+/) # => [\"20070926\", \"155656\"]\n d1 = \"#{d[0..3]}-#{d[4..5]}-#{d[6..7]}\" # => \"2007-09-26\"\n t1 = \"#{t[0..1]}:#{t[2..3]}:#{t[4..5]}\" # => \"15:56:56\"\n dt = \"#{d1}T#{t1}Z\" # => \"2007-09-26T15:56:56Z\"\n date_time = DateTime.parse(dt) # => #<DateTime: 10673317777/10800,0,2299161>\n # revision\n if md3 = md2.post_match.match(/\\d+/)\n revision = md3[0].to_i\n end\n else\n if match = md.post_match[/\\d+/]\n revision = match.to_i\n end\n end\n # certificate_version\n if match = md.post_match[/-(s\\d+)/, 1]\n certificate_version = match\n end\n end\n end\n [version, revision, date_str, date_time, certificate_version]\n end",
"def osgi_version_for(version)\n parts = version.split(/[\\.,-]/)\n result = Array.new(3, 0)\n parts.each_index { |i|\n if (result.size == 3) then\n if (parts[i] =~ /\\d+/) then result[i] = parts[i] else result = result << parts[i] end\n else\n result[3] = [result[3], parts[i]].join(\"-\")\n end\n }\n result.join(\".\")\nend",
"def parse(version)\n version.scan(/[0-9]+|[A-z]+/).map! do |str|\n str =~ /^\\d+$/ ? str.to_i : str\n end\n end",
"def version(str)\n @version = str\n end",
"def versioned(version)\n version_named(version.to_sym)\n end",
"def version=(string)\n @table[:version] = Version::Number.new(string) if string\n end",
"def nextVersion(version)\n return version.to_i.next.to_s if !version.include? '.'\n\n top, bottom = version.split('.', 2)\n bottom = bottom.split('.').join\n\n new_bottom = bottom.to_i.next.to_s\n\n if new_bottom.length > bottom.length\n top = top.to_i.next\n new_bottom = new_bottom.chars.drop(1).join\n end\n\n [top, new_bottom.chars.join('.')].join '.'\nend",
"def initialize(version = Version.create('0'))\n @version = version\n end",
"def parse_version( vers )\n @version_major = nil\n @version_minor = nil\n @version_patch = nil\n @version_extra = nil\n if vers\n vers.match(/(.*)\\.(.*)\\.(\\d*)(.*)/) do |matches|\n @version_major = matches[1]\n @version_minor = matches[2]\n @version_patch = matches[3]\n @version_extra = matches[4]\n end\n @version_plain = \"#{@version_major}.#{@version_minor}.#{@version_patch}\"\n end\n end",
"def initialize(version = :niv)\n raise InvalidBibleVersion unless BIBLE_VERSIONS.has_key?(version)\n\n @version = version.to_s.upcase\n @version_number = BIBLE_VERSIONS[version][:id]\n @version_name = BIBLE_VERSIONS[version][:name]\n super()\n end",
"def version_number(str)\n if str =~ /\\d/\n str.gsub(/^[^\\d]*/, '').gsub(/[^\\d]*$/, '').gsub(/(\\d*\\.\\d*).*/, '\\1')\n else\n '-'\n end\n end",
"def version\n @version ||= version_hex.to_s(16).chars.entries.join('.')\n end",
"def choose_version(version)\n if version =~ /(\\d+)\\.(\\d+)\\.(\\d+)/\n major = $1\n minor = $2\n patch = $3\n if config[:major]\n major = major.to_i + 1\n minor = 0\n patch = 0\n end\n if config[:minor]\n minor = minor.to_i + 1\n patch = 0\n end\n patch = patch.to_i + 1 if config[:patch]\n version = \"#{major}.#{minor}.#{patch}\"\n Chef::Log.debug(\"New version is #{version}\")\n else\n Chef::Log.error(\"Version is in a format I cannot auto-update\")\n exit 1\n end\n version\n end",
"def initialize(type, version)\n @type = type\n @version = version\n @parsed_version = Gem::Version.new(version)\n end",
"def jamm_version(version)\n case version.to_s.strip\n when /^0.[0-7]/\n '0.2.5'\n when /^0.8/\n '0.2.2'\n when /^1|^2.0/\n '0.2.5'\n when /^2.1.[0-1]$/\n '0.2.6'\n when /^2.1.[2-3]$/\n '0.2.8'\n when /^2.1/\n '0.3.1'\n when /^2.2/\n '0.3.1'\n when /^3.[0-9]/\n '0.3.1'\n end\nend",
"def by_version(version)\n raise Version::Error unless version.match(Version::FORMAT) && respond_to?(version)\n\n send(version)\n end",
"def nextVersion(version)\n\n current_version = version.split('.').reverse;\n new_version = [];\n\n if version.split('.').length == 1\n (version.to_i + 1).to_s\n else\n current_version.map.with_index do |n,i|\n if i == 0\n new_n = (n.to_i + 1).to_s\n if new_n == '10'\n new_version.push('0')\n current_version[i+1] = (current_version[i+1].to_i + 1).to_s\n else\n new_version.push(new_n)\n end\n else\n if n == '10'\n if i == (current_version.length - 1)\n new_version.push(n)\n else\n new_version.push('0')\n current_version[i+1] = (current_version[i+1].to_i + 1).to_s\n end\n else\n new_version.push(n)\n end\n end\n end\n new_version.reverse.join('.')\n end\n\nend",
"def version_string_to_a( v )\n if v.is_a?( String )\n v.split(/[.\\-]/).map do |p|\n if p =~ /^\\d+$/\n p.to_i\n else\n p\n end\n end\n else\n v\n end\n end",
"def _validate_version(v)\n if v.to_s.empty?\n results.add_error('version', 'A version is required.')\n elsif v <= Version::ZERO\n results.add_error('version', 'The version of the spec should be' \\\n ' higher than 0.')\n end\n end",
"def validate_version(version)\n return if SemanticPuppet::Version.valid?(version)\n\n err = \"version string cannot be parsed as a valid Semantic Version\"\n raise ArgumentError, \"Invalid 'version' field in metadata.json: #{err}\"\n end",
"def load_version(version)\n if version.is_a?(String)\n if version =~ /^\\d+$/\n version = version.to_i\n else\n version = Time.parse(version)\n end\n elsif version.is_a?(Date)\n Time.parse(version.to_s)\n end\n merged = serialize.tap do |hash|\n versions.select { |h| version.is_a?(Integer) ? h.version >= version : h.created_at > version }\n .sort_by { |h| h.version }.reverse\n .each { |h| hash.deep_merge!(h.changes) }\n end\n self.class.new(merged)\n end",
"def next_version\n # x.y.z\n v = version.split '.'\n # bump z\n v[-1] = v[-1].to_i + 1\n v.join '.'\nend",
"def test_parsing_with_string\n value_ = ::Versionomy.parse('1.9.2pre2', :semver)\n assert_equal([1, 9, 2, 'pre2'], value_.values_array)\n assert_equal('1.9.2pre2', value_.unparse)\n end",
"def initialize(version, prefix = 'v')\n version.gsub!(/^#{prefix}/, '') # remove leading prefix\n super(version)\n end",
"def convert_http_version( version_string )\n\t\t\treturn case version_string\n\t\t\t\twhen '1.0'\n\t\t\t\t\t:httpv1_0\n\t\t\t\twhen '1.1'\n\t\t\t\t\t:httpv1_1\n\t\t\t\twhen '2.0'\n\t\t\t\t\t:httpv2_0\n\t\t\t\telse\n\t\t\t\t\tversion_string.to_sym\n\t\t\t\tend\n\t\tend",
"def set_version(value)\n if value.nil?\n @version = 'latest'\n else\n return skip_resource 'Invalid character in version' unless value.to_s =~ /^(latest|[\\d\\.-]+)$/\n @version = value\n end\n end",
"def version=(version)\n case version\n when VersionNumber\n @version = version\n when Hash\n major = version['major']\n minor = version['minor']\n patch = version['patch']\n build = version['build']\n\n @version = VersionNumber.new(major,minor,patch,build)\n when String\n @version = VersionNumber.parse(version.to_s)\n else\n raise(InvalidMetadata,\"version must be a Hash or a String\")\n end\n end",
"def get_version(version)\n unless version > 0\n raise OcflTools::Errors::NonCompliantValue, \"Requested value '#{version}' for object version does not comply with specification.\"\n end\n if @versions.key?(OcflTools::Utils.version_int_to_string(version))\n @versions[OcflTools::Utils.version_int_to_string(version)]\n else\n # Otherwise, construct a new Version [Hash] and return that.\n @versions[OcflTools::Utils.version_int_to_string(version)] = create_version_hash\n\n # If version -1 exists, copy prior version state over.\n if @versions.key?(OcflTools::Utils.version_int_to_string(version - 1))\n @versions[OcflTools::Utils.version_int_to_string(version)]['state'] = OcflTools::Utils.deep_copy(@versions[OcflTools::Utils.version_int_to_string(version - 1)]['state'])\n end\n\n @versions[OcflTools::Utils.version_int_to_string(version)]\n end\n end",
"def client_meta_version(version)\n regexp = /^([0-9]+\\.[0-9]+\\.[0-9]+)(\\.?[a-z0-9.-]+)?$/\n match = version.match(regexp)\n return \"#{match[1]}p\" if (match[2])\n\n version\n end",
"def to_a()\n major, minors = @string.split(DOT)\n versions = (minors || '').scan(DIGIT)\n versions.unshift(major, '.')\n versions\n end",
"def version_conversion(ver, separator = '.')\n\tver_simple = ver.split(separator)\n\tver_simple.map { |i| i.to_s.sub!(/(^0)/, '') }\n\treturn ver_simple.join(separator)\nend",
"def next_version #:nodoc:\n parts = version.split('.')\n parts[-1] = (parts[-1].to_i + 1).to_s\n parts.join('.')\n end",
"def initialize(version)\n @version = version\n end",
"def vvec( version_string )\n\t\t\treturn version_string.split( '.' ).\n\t\t\t\tcollect {|num| num.to_i }.pack( 'N*' )\n\t\tend",
"def GetVersionParts(versionStr)\n version_vals = versionStr.split('-')\n major, minor, patch = version_vals[0].split('.')\n build = version_vals[1]\n return major, minor, patch, build\n end",
"def initialize(name, version)\n @name = name\n @version = version\n end",
"def version_to_namespace(version)\n version.gsub('.', '')\n end",
"def from_tag(tag)\n matchdata = tag.match VERSION_FORMAT\n new(matchdata[:major], matchdata[:minor], matchdata[:patch], Prerelease.from_string(matchdata[:prerelease]), matchdata[:build])\n end",
"def version\n build_string\n end",
"def test_format_to_s\n version = VMLib::Version.new 'foo', 1, 2, 3, 'rc.1', 'sha.5114f85'\n\n # Make sure all fields are included in the to_s\n assert_equal 'foo 1.2.3-rc.1+sha.5114f85', version.to_s\n\n # Changing the name should reflect in the to_s\n version.name = 'bar'\n assert_equal 'bar 1.2.3-rc.1+sha.5114f85', version.to_s\n\n # Changing the major number should reflect in the to_s\n version.major = 4\n assert_equal 'bar 4.2.3-rc.1+sha.5114f85', version.to_s\n\n # Changing the minor number should reflect in the to_s\n version.minor = 5\n assert_equal 'bar 4.5.3-rc.1+sha.5114f85', version.to_s\n\n # Changing the patch number should reflect in the to_s\n version.patch = 6\n assert_equal 'bar 4.5.6-rc.1+sha.5114f85', version.to_s\n\n version.major = 1\n version.minor = 2\n version.patch = 3\n\n # Changing the build should reflect in the to_s\n version.build = 'sha.0012312'\n assert_equal 'bar 1.2.3-rc.1+sha.0012312', version.to_s\n\n # Removing the build should reflect in the to_s\n version.build = ''\n assert_equal 'bar 1.2.3-rc.1', version.to_s\n\n # Changing the prerelease should reflect in the to_s\n version.prerelease = 'alpha.02'\n assert_equal 'bar 1.2.3-a.2', version.to_s\n\n # Removing the prerelease should reflect in the to_s\n version.prerelease = ''\n assert_equal 'bar 1.2.3', version.to_s\n\n # Having a build metadata and no prerelease should reflect in the to_s\n version.build = 'sha.12ab32d'\n assert_equal 'bar 1.2.3+sha.12ab32d', version.to_s\n end",
"def major_version\n version.match(/(\\d\\.\\d)/)[0] if name.is_a? String\n end",
"def test_standard_to_semver_with_v\n value_ = ::Versionomy.parse('v1.2.3')\n value2_ = value_.convert(:semver)\n assert_equal([1, 2, 3, ''], value2_.values_array)\n value_ = ::Versionomy.parse('V 1.2.3')\n value2_ = value_.convert(:semver)\n assert_equal([1, 2, 3, ''], value2_.values_array)\n end",
"def major_version(version = nil)\n version ||= installed_version?\n return \"0\" if version.nil?\n\n version.sub(/(\\.\\d+)+$/, '')\n end",
"def gem_version(version)\n Gem::Version.create(version)\n end",
"def parser_for_version(version)\n require \"parser/#{version}\"\n Parser.const_get version.capitalize\n end",
"def build_version\n @semver.to_s '%M.%m.%p'\n end",
"def initialize(version)\n segments = Gem::Version.new(version).segments\n\n @level = segments[2] != 0 ? :patch : :minor_or_major\n\n @stable_branch = segments[0, 2].join(\".\")\n @previous_stable_branch = @level == :minor_or_major ? \"#{segments[0]}.#{segments[1] - 1}\" : @stable_branch\n\n rubygems_version = segments.join(\".\")\n @rubygems = Rubygems.new(rubygems_version, @stable_branch)\n\n bundler_version = segments.map.with_index {|s, i| i == 0 ? s - 1 : s }.join(\".\")\n @bundler = Bundler.new(bundler_version, @stable_branch)\n\n @release_branch = \"release/bundler_#{bundler_version}_rubygems_#{rubygems_version}\"\n end",
"def ver\n if v = version\n str = +\"#{program_name} #{[v].join('.')}\"\n str << \" (#{v})\" if v = release\n str\n end\n end",
"def major_version(full_version)\n full_version.match(/^(\\d+\\.\\d+\\.\\d+)\\.\\d+$/)[1]\n end",
"def read_version\n # The version string is usually in one of the following formats:\n #\n # * 4.1.8r1234\n # * 4.1.8r1234_OSE\n # * 4.1.8_MacPortsr1234\n #\n # Below accounts for all of these:\n execute(\"--version\").split(\"_\")[0].split(\"r\")[0]\n end",
"def version=(arg)\n @version = arg.to_s\n end",
"def get_version(str)\n\tmatches = str.match(VERSION_REGEX)\n\treturn matches[0].gsub(/[\\(\\)]/, '')\nend",
"def new_version_url(version)\n\t\turl_parts = self.url.split(\"-\")\n\t\tunless url_parts.size < 3\n\t\t\tcase version\n\t\t\twhen \"major\"\n\t\t\t\turl_parts[url_parts.size - 2] = self.maj_version += 1\n\t\t\twhen \"minor\" \n\t\t\t\turl_parts[url_parts.size - 1] = self.min_version += 1\n\t\t\tend\n\t\telse\n\t\t\tcase version\n\t\t\twhen \"major\"\n\t\t\t\turl_parts.push(self.maj_version += 1, self.min_version)\n\t\t\twhen \"minor\" \n\t\t\t\turl_parts.push(self.maj_version, self.min_version += 1)\n\t\t\tend\n\t\tend\n\t\treturn url_parts.join(\"-\")\n\tend",
"def major(version)\n res = 0\n res = Regexp.last_match(1) if version =~ /^\\s*(\\d+)\\.\\d+\\.\\d+/\n res\n end",
"def extract_os_version(version)\n #version.unpack('CCS').join('.')\n begin\n os_version = NTLM::OSVersion.read(version)\n rescue IOError\n return ''\n end\n return \"#{os_version.major}.#{os_version.minor}.#{os_version.build}\"\n end",
"def version_by_id(version_str)\n version_id = File.join(component_id, version_str)\n finder.versions.cache(version_id) do\n info_versions = components.map do |c|\n Repository::Version.new(version_str).version_id(version_id).parent(c)\n end\n existing_versions = info_versions.select do |v|\n v.exist?\n end\n Version.new.component(self).version_id(version_id).name(version_str).versions(existing_versions)\n end\n end",
"def test_parsing_with_string\n value_ = ::Versionomy.parse('1.9.2.pre.2', :rubygems)\n assert_equal([1, 9, 2, 'pre', 2, 0, 0, 0], value_.values_array)\n assert_equal('1.9.2.pre.2', value_.unparse)\n end",
"def set_version(version)\n file_sub(GEMSPEC, /(\\.version\\s*=\\s*).*/, \"\\\\1'#{version}'\")\n file_sub(VERSION_RB, /^(\\s*VERSION\\s*=\\s*).*/, \"\\\\1'#{version}'\")\nend",
"def get_version!(version)\n version.gsub!('_', '.')\n\n if version == 'latest'\n latest_extension_version\n else\n extension_versions.find_by!(version: version)\n end\n end",
"def version_number(version_id)\n version_id.gsub(VERSION_REGEX, '\\1').to_i\n end",
"def version\n name.split('_')[1]\n end",
"def dcl_version(version)\n return '' if version == 'ga'\n return '/beta' if version == 'beta'\n return '/alpha' if version == 'private'\n end",
"def version=(v)\n @version = v\n end",
"def version=(version) # :nodoc:\n @fields['version'] = version.to_s\n end",
"def normalize_version(version)\n version.to_s.tr(';', '')\n end",
"def test_accepts_version_through_constructor\n Crd::Spec.new 'Testing', '1.0.4' do |s|\n assert_equal( '1.0.4', s.version )\n end\n end",
"def version_const\n \"Version_\" + @__version.upcase.gsub(\".\", \"_\")\n end",
"def build_version\n string = plist_buddy.plist_read(\"CFBundleVersion\", info_plist_path)\n begin\n version = RunLoop::Version.new(string)\n rescue\n if string && string != \"\"\n RunLoop.log_debug(\"CFBundleVersion: '#{string}' is not a well formed version string\")\n else\n RunLoop.log_debug(\"CFBundleVersion is not defined in Info.plist\")\n end\n version = nil\n end\n version\n end",
"def check_version(v)\n return true if (!version || version[0..4].gsub(\".\",\"\").to_i>=v)\n return false\n end",
"def sub_version\n \">= \".concat(version.split('.').first(2).join('.'))\n end",
"def version=(val)\n if (val.kind_of?(Integer)) \n make_major_minor_version(val & 0xff)\n elsif(val.kind_of?(String))\n raise ArgumentError, \"Value should be 1-byte, but was #{val.length}.\" if (val.length != 1) \n make_major_minor_version(val.unpack('C')[0])\n else\n raise ArgumentError, \"Expected Integer, but #{val.class} provided.\" \n end\n end",
"def minor_version(version = nil)\n version ||= installed_version?\n return \"0.0\" if version.nil?\n\n version.sub(/\\.\\d+$/, '')\n end",
"def version\n str = if product = detect_product('Version')\n product.version\n elsif os =~ /iOS ([\\d\\.]+)/ && browser == \"Safari\"\n $1.tr('_', '.')\n else\n BuildVersions[build.to_s]\n end\n\n Version.new(str)\n end",
"def version_type(version)\n data = Settings::ProgramSettings.new.parse(\"https://github.com/Ekultek/whitewidow/blob/master/lib/misc/banner.rb\", \"td\", 57)\n arr = data.split(\" \")\n version_number = arr[7][/(\\d+\\.)?(\\d+\\.)?(\\d+\\.)?(\\*|\\d+)/]\n if version.count(\".\") <= 2\n return \"stable\".green.bold\n elsif version.length >= 3\n return \"dev\".yellow.bold\n elsif version != version_number\n return \"upgrade available\".red.bold\n else\n return \"unknown version type\".red.bold\n end\n\n end",
"def set_version_name!\n if patterns = @name.match(/^(.*) \\[(.*)\\](.*)$/)\n @name = \"#{patterns[1]}#{patterns[3]}\"\n @version_name = patterns[2]\n end\n end",
"def to_param\n version.gsub(/\\./, '_')\n end",
"def create\n @version = Version.new(params[:version])\n\n respond_to do |format|\n if @version.save\n format.html { redirect_to @version, notice: 'Version was successfully created.' }\n format.json { render json: @version, status: :created, location: @version }\n else\n format.html { render action: \"new\" }\n format.json { render json: @version.errors, status: :unprocessable_entity }\n end\n end\n end",
"def from_string(string)\n from_bits(*Builder::FromString.new(string).bits)\n end",
"def infer_version_from_version_file\n vfile = root.glob('VERSION{,.txt,.yml,.yaml}', File::FNM_CASEFOLD).first\n if vfile && vfile.exist?\n text = vfile.read.strip\n case text\n when /\\A---/\n type = :yaml\n when /\\A\\d+[.]/\n type = :text\n when /[:]/\n type = :yaml\n else\n type = nil\n end\n\n case type\n when :yaml\n data = YAML.load(text)\n data = data.inject({}){|h,(k,v)| h[k.to_sym]=v; h}\n text = data.values_at(:major,:minor,:patch,:build).compact.join('.')\n set :version, text\n when :text\n set :version, text\n end\n end\n end",
"def get_version(version)\n decode_doc(@ram_versions[version])\n end",
"def safe_version(version_name)\n \t _version = send(version_name) if respond_to?(version_name)\n \t \n\t unless _version.nil? || File.exist?(_version.path)\n\t \trecreate_versions!(version_name)\n\t end\n\t _version\n end",
"def test_standard_to_semver_simple\n value_ = ::Versionomy.parse('1.2')\n value2_ = value_.convert(:semver)\n assert_equal(@semver_format, value2_.format)\n assert_equal([1, 2, 0, ''], value2_.values_array)\n value_ = ::Versionomy.parse('1.2.4')\n value2_ = value_.convert(:semver)\n assert_equal(@semver_format, value2_.format)\n assert_equal([1, 2, 4, ''], value2_.values_array)\n end",
"def version_munger(version_string, default: '=')\n match = version_string.match(VERSION_REGEX)\n\n if match.nil?\n VanagonLogger.info \"Passing a version without an operator is deprecated!\"\n operator = default\n version = version_string\n end\n operator ||= match[1]\n version ||= match[2]\n fail \"Operator '#{operator}' is invalid\" unless validate_operator(operator)\n \"#{operator} #{version}\"\n end",
"def version\n m = VERSION_REGEX.match(@text)\n return -1 unless m\n\n m[1].to_i\n end",
"def get_version_argument\n version = ENV['VERSION']\n if version.to_s.empty?\n raise \"No version specified: Add VERSION=X.Y.Z to the command line\"\n end\n begin\n Gem::Version.create(version.dup)\n rescue ArgumentError\n raise \"Invalid version specified in `VERSION=#{version}'\"\n end\nend"
] |
[
"0.76013184",
"0.75010276",
"0.73253834",
"0.72288823",
"0.7208856",
"0.71559083",
"0.7001371",
"0.6874154",
"0.6782436",
"0.676036",
"0.6743286",
"0.6697681",
"0.6619271",
"0.6619271",
"0.6534759",
"0.648085",
"0.6453774",
"0.6436464",
"0.64097077",
"0.63496315",
"0.63113314",
"0.62196374",
"0.6206693",
"0.61521196",
"0.61483526",
"0.6102621",
"0.6073483",
"0.60726583",
"0.60680926",
"0.603158",
"0.6011991",
"0.60083437",
"0.5994709",
"0.5981032",
"0.59786713",
"0.5930759",
"0.5923094",
"0.5888976",
"0.5886985",
"0.5862165",
"0.58377814",
"0.5836134",
"0.5814642",
"0.58100325",
"0.58088017",
"0.57901305",
"0.57739824",
"0.57661533",
"0.57446074",
"0.57263154",
"0.56982374",
"0.56914634",
"0.5690176",
"0.56711227",
"0.5655919",
"0.5651776",
"0.56364363",
"0.56277674",
"0.56159323",
"0.56063116",
"0.55825114",
"0.5579634",
"0.5579413",
"0.5567784",
"0.55664384",
"0.5558457",
"0.55474424",
"0.5545826",
"0.5538643",
"0.5534039",
"0.55218786",
"0.5517423",
"0.55115396",
"0.5509231",
"0.548193",
"0.54778194",
"0.54602045",
"0.54543453",
"0.5452151",
"0.545022",
"0.54243153",
"0.541678",
"0.5375553",
"0.5345356",
"0.53424037",
"0.53081906",
"0.5304951",
"0.5299945",
"0.5295734",
"0.5269711",
"0.5262345",
"0.52618647",
"0.52578837",
"0.5254511",
"0.5251667",
"0.5249541",
"0.52457917",
"0.52384055",
"0.5225688",
"0.5224056"
] |
0.74028313
|
2
|
Return a new version object where the next to the last revision number is one greater (e.g., 5.3.1 => 5.4).
|
def bump
@bump ||= begin
segments = self.segments
segments.pop if segments.size > 1
segments[-1] = segments[-1].succ
self.class.new segments.join(".")
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def bump\n parts = parse_parts_from_version_string\n parts.pop while parts.any? { |part| part.alpha? }\n parts.pop if parts.size > 1\n parts[-1] = parts[-1].succ\n self.class.new(parts.join(\".\"))\n end",
"def last_version\n @last_version ||= versions.maximum(:number) || 1\n end",
"def nextVersion\n newRevision(@year, @month, @revCount.nil? ? 1 : @revCount + 1)\n end",
"def last_version_number\n last = versions.first\n last ? last.number : 0\n end",
"def next_version( number )\n find( :first, :order => 'number ASC', :conditions => [ \"number > ?\", number ] )\n end",
"def next_version\n # x.y.z\n v = version.split '.'\n # bump z\n v[-1] = v[-1].to_i + 1\n v.join '.'\nend",
"def last_version_number\n\t last = versions.first\n\t last ? last.number : 0\n\t end",
"def previous_version( number )\n find( :first, :order => 'number DESC', :conditions => [ \"number < ?\", number ] )\n end",
"def last_version\n return 0 if versions.count == 0\n versions.first.version_number\n end",
"def latest_version\n\t\treturn versions.order(\"number DESC\").last\n\tend",
"def nextVersion(version)\n\n current_version = version.split('.').reverse;\n new_version = [];\n\n if version.split('.').length == 1\n (version.to_i + 1).to_s\n else\n current_version.map.with_index do |n,i|\n if i == 0\n new_n = (n.to_i + 1).to_s\n if new_n == '10'\n new_version.push('0')\n current_version[i+1] = (current_version[i+1].to_i + 1).to_s\n else\n new_version.push(new_n)\n end\n else\n if n == '10'\n if i == (current_version.length - 1)\n new_version.push(n)\n else\n new_version.push('0')\n current_version[i+1] = (current_version[i+1].to_i + 1).to_s\n end\n else\n new_version.push(n)\n end\n end\n end\n new_version.reverse.join('.')\n end\n\nend",
"def next_version\n (new_record? ? 0 : versions.calculate(:maximum, version_column).to_i) + 1\n end",
"def initial_version\n version - changes.size\n end",
"def next_version #:nodoc:\n parts = version.split('.')\n parts[-1] = (parts[-1].to_i + 1).to_s\n parts.join('.')\n end",
"def nextVersion(version)\n return version.to_i.next.to_s if !version.include? '.'\n\n top, bottom = version.split('.', 2)\n bottom = bottom.split('.').join\n\n new_bottom = bottom.to_i.next.to_s\n\n if new_bottom.length > bottom.length\n top = top.to_i.next\n new_bottom = new_bottom.chars.drop(1).join\n end\n\n [top, new_bottom.chars.join('.')].join '.'\nend",
"def set_version\n self.version ||= latest_version + 1\n end",
"def latest_version\n self.class::Versions.max {|a, b| Ajaxlibs::VersionsTools.compare a, b}\n end",
"def next_revision(revision)\n revision.to_i + 1\n end",
"def new_version\n %w(major minor patch).each do |level|\n changes = git_changelog.select(&\"#{level}?\".to_sym)\n return [ last_release.send(\"#{level}!\"), changes ] if changes.size > 0\n end\n raise \"No commit since last release (#{last_release})\"\n end",
"def latest_version\n self.versions.order(\"revision_date DESC\").first\n end",
"def version_at(timestamp, reify_options={})\n # Because a version stores how its object looked *before* the change,\n # we need to look for the first version created *after* the timestamp.\n version = versions.after(timestamp).first\n version ? version.reify(reify_options) : self\n end",
"def next\n versionable.versions.next_version( self.number )\n end",
"def current_version\n find( :first, :order => 'number DESC' )\n end",
"def next_revision_number\n # Need to retrieve existing revision numbers to sort them as integers\n sql = \"SELECT revision FROM #{Changeset.table_name} \" \\\n \"WHERE repository_id = #{id} AND revision NOT LIKE 'tmp%'\"\n @current_revision_number ||= (self.class.connection.select_values(sql).collect(&:to_i).max || 0)\n @current_revision_number += 1\n end",
"def first_version\n find( :first, :order => 'number ASC' )\n end",
"def latest_extension_version\n versions = remove_non_semvar_versions\n versions = remove_pre_release_versions(versions)\n if versions.blank?\n # include pre-release versions\n versions = remove_non_semvar_versions\n end\n if versions.blank?\n # use the non-compliant versions as last resort\n versions = sorted_extension_versions\n end\n versions.first\n end",
"def current_version\n version_number rev\n end",
"def next_logical_version(increment = 1)\n return false if patchlevel_is_significant?\n split_version = @version_without_patchlevel.split(\".\")\n teeny = split_version.pop\n split_version << teeny.to_i + increment\n split_version.join(\".\")\n end",
"def version\n return last_version if versionable?\n version_number\n end",
"def newest_version\n detect_newest_version if @newest_version == UnknownVersion\n\n @newest_version\n end",
"def next_version \n # NOTE: if self (the item) was not reified from a version, i.e. it is the\n # \"live\" item, we return nil. Perhaps we should return self instead?\n subsequent_version = trail_version ? next_trail_version : nil\n subsequent_version.reify if subsequent_version\n end",
"def latest_version\n files.last && files.last.versionnumber\n end",
"def previous_version\n current_version - 1\n end",
"def next_version\n subsequent_version = source_version.next\n subsequent_version ? subsequent_version.reify : @record.class.find(@record.id)\n rescue StandardError # TODO: Rescue something more specific\n nil\n end",
"def next_version\n subsequent_version = source_version.next\n subsequent_version ? subsequent_version.reify : @record.class.find(@record.id)\n rescue StandardError # TODO: Rescue something more specific\n nil\n end",
"def test_that_bumping_with_prereleases\r\n v = Bumper::Version.new\r\n assert_equal '0.0.0.0', v.to_s\r\n assert_equal 1, v.bump_minor\r\n assert_equal '0.1.0.0', v.to_s\r\n assert_equal 'beta', v.bump_patch_tag('beta')\r\n assert_equal '0.1.1-beta.0', v.to_s\r\n assert_equal 'beta2', v.bump_patch_tag('beta')\r\n assert_equal '0.1.1-beta2.0', v.to_s\r\n assert_equal '1', v.bump_build\r\n assert_equal '0.1.1-beta2.1', v.to_s\r\n assert_equal 'rc', v.bump_patch_tag('rc') # replaces tag\r\n assert_equal '0.1.1-rc.0', v.to_s\r\n assert_equal 'rc2', v.bump_patch_tag('rc')\r\n assert_equal '0.1.1-rc2.0', v.to_s\r\n assert_equal 1, v.bump_patch # drops tag\r\n assert_equal '0.1.1.0', v.to_s\r\n assert_equal 2, v.bump_patch\r\n assert_equal '0.1.2.0', v.to_s\r\n assert_equal 2, v.bump_minor\r\n assert_equal '0.2.0.0', v.to_s\r\n assert_equal 'alpha', v.bump_patch_tag('alpha')\r\n assert_equal '0.2.1-alpha.0', v.to_s\r\n assert_equal 3, v.bump_minor\r\n assert_equal '0.3.0.0', v.to_s\r\n v.build = 'rc1'\r\n assert_equal '0.3.0.rc1', v.to_s\r\n assert_equal 'rc2', v.bump_build\r\n assert_equal '0.3.0.rc2', v.to_s\r\n end",
"def get_version(version)\n unless version > 0\n raise OcflTools::Errors::NonCompliantValue, \"Requested value '#{version}' for object version does not comply with specification.\"\n end\n if @versions.key?(OcflTools::Utils.version_int_to_string(version))\n @versions[OcflTools::Utils.version_int_to_string(version)]\n else\n # Otherwise, construct a new Version [Hash] and return that.\n @versions[OcflTools::Utils.version_int_to_string(version)] = create_version_hash\n\n # If version -1 exists, copy prior version state over.\n if @versions.key?(OcflTools::Utils.version_int_to_string(version - 1))\n @versions[OcflTools::Utils.version_int_to_string(version)]['state'] = OcflTools::Utils.deep_copy(@versions[OcflTools::Utils.version_int_to_string(version - 1)]['state'])\n end\n\n @versions[OcflTools::Utils.version_int_to_string(version)]\n end\n end",
"def latest_version\n file_to_semver(sorted_files.first)\n end",
"def previous_version\n preceding_version = trail_version ? previous_trail_version : versions.last\n preceding_version.try :reify\n end",
"def revision(version)\n if version == :previous || audits.last.version >= version\n revision_with Audited.audit_class.reconstruct_attributes(audits_to(version))\n end\n end",
"def next_revision_number(existing_model)\n existing_model.revision_number + 1\n end",
"def last_revision\n self.revision_model.find(:first, :conditions => { klass + '_id' => self.id }, :order => \"number DESC\")\n end",
"def revision_number\n ver = version\n case\n when live? then\n versions.count\n when ver then\n ver.index\n else\n 0\n end\n end",
"def last_version(sorted_versions)\n sorted_versions.blank? ? '' : sorted_versions.last\nend",
"def previous_version\n (source_version ? source_version.previous : versions.last).try(:reify)\n end",
"def previous_version\n (source_version ? source_version.previous : versions.last).try(:reify)\n end",
"def last_version(sorted_versions)\n sorted_versions.blank? ? '' : sorted_versions.last\n end",
"def older_version v1, v2\n v1 = v1.split('.').map{|s|s.to_i}.extend(Comparable)\n v2 = v2.split('.').map{|s|s.to_i}.extend(Comparable)\n return v1 < v2\n end",
"def revision\n @revision ||= if token.nil? || relevant_packages.empty?\n 1\n else\n relevant_packages.map do |p|\n p['release'].to_i\n end.sort.last + 1\n end\n end",
"def make_last_revision_earlier(model)\n Revision.record_timestamps = false\n model.revisions.last.update_attributes :created_at => 2.seconds.ago\n Revision.record_timestamps = true\n end",
"def last_version(version_type)\n case version_type\n when :patch\n available_versions.select { |v| v =~ /^#{major}\\.#{minor}\\D/ }.first\n when :minor\n available_versions.select { |v| v =~ /^#{major}\\./ }.first\n when :major\n available_versions.first\n else\n raise \"Invalid version_type: #{version_type}\"\n end\n end",
"def last_version(version_type)\n case version_type\n when :patch\n available_versions.select { |v| v =~ /^#{major}\\.#{minor}\\D/ }.first\n when :minor\n available_versions.select { |v| v =~ /^#{major}\\./ }.first\n when :major\n available_versions.first\n else\n raise \"Invalid version_type: #{version_type}\"\n end\n end",
"def previous\n @previous ||= CmsContentVersion.\n reorder('version DESC').\n includes(:author).\n where(\"versionable_type = ? AND versionable_id = ? AND version < ?\",\n versionable.class, versionable.id, version).first\n end",
"def next_release_number\n latest_samson_number = project.releases.last&.number || \"0\"\n next_samson_number = next_number(latest_samson_number)\n return next_samson_number if commit.blank?\n\n return next_samson_number unless fuzzy_tag = project.repository.fuzzy_tag_from_ref(commit)&.split('-', 2)\n return next_samson_number unless latest_github_number = fuzzy_tag.first[VERSION_REGEX, 1]\n next_github_number = (fuzzy_tag.size == 1 ? latest_github_number : next_number(latest_github_number))\n\n if Gem::Version.new(next_samson_number) > Gem::Version.new(next_github_number)\n next_samson_number\n else\n next_github_number\n end\n end",
"def last_revision\n get_revision('REVISION')\n end",
"def next_revision(include_metadata=false)\n revs = notebook.revisions.where('id > ?', id)\n revs = revs.where.not(revtype: 'metadata') unless include_metadata\n revs.first\n end",
"def version_gap\n memoize(:version_gap) do\n return unless version && versions\n\n index = versions.index { |v| v[:number] == version }\n return unless index\n\n gap = versions[0..index].count { |v| !v[:prerelease] } - 1\n gap.positive? ? gap : 0\n end\n end",
"def sub_version\n \">= \".concat(version.split('.').first(2).join('.'))\n end",
"def new_version\n @version = Time.now.to_i\n end",
"def next_version\n work.next_version\n end",
"def revision\n self.major_rev_number.to_s + '.' + self.minor_rev_number.to_s\n end",
"def load_previous_version\n Version.all(:limit => 1, :order => [ :processed.desc ]).first\n end",
"def next_revision\n self.class.find(:first, :conditions => {:revisable_original_id => revisable_original_id, :revisable_number => revisable_number + 1})\n end",
"def previous_version\n @previous_version ||= previous_versions[0]\n end",
"def next_revision\n self.class.find_by(\n revisable_original_id: revisable_original_id,\n revisable_number: revisable_number + 1\n )\n end",
"def previous(version)\n # San check, does version exist in object?\n if version == 1\n get_first_version_delta\n else\n # verify version exists, then...\n unless @ocfl_object.version_id_list.include?(version)\n raise \"Version #{version} not found in #{@ocfl_object}!\"\n end\n get_version_delta(version)\n end\n end",
"def decrement_version!\n @_aggregate.instance_variable_set(:@local_version, local_version - 1)\n\n self\n end",
"def previous\n @previous ||= WikiContent::Version.\n reorder('version DESC').\n includes(:author).\n where(\"wiki_content_id = ? AND version < ?\", wiki_content_id, version).first\n end",
"def first\n document.new? ? document.clone.extend(VersionedDocument) : self[all_preceding_versions.last]\n end",
"def max_version\n all_versions.max\n end",
"def revert_to version\r\n while !@data.nil? && @data.version > version\r\n @data = @data.prev_version\r\n end\r\n !@data.nil?\r\n end",
"def version_gt(v1, v2)\n # Construct an array to make sure the shorter version is padded with nil\n Array.new([v1.length, v2.length].max).zip(v1.split(\".\"), v2.split(\".\")) do |_, p1, p2|\n p1 ||= \"0\"\n p2 ||= \"0\"\n release1 = p1 =~ /^[0-9]+$/\n release2 = p2 =~ /^[0-9]+$/\n if release1 && release2\n # Integer comparison if both are full releases\n p1, p2 = p1.to_i, p2.to_i\n next if p1 == p2\n return p1 > p2\n elsif !release1 && !release2\n # String comparison if both are prereleases\n next if p1 == p2\n return p1 > p2\n else\n # If only one is a release, that one is newer\n return release1\n end\n end\n end",
"def version\n next_version\n end",
"def version_behind(input, n)\n input.each do |group|\n if group[\"versions\"].length > n\n return group[\"versions\"][n]\n end\n end\n end",
"def next\n @next ||= WikiContent::Version.\n reorder('version ASC').\n includes(:author).\n where(\"wiki_content_id = ? AND version > ?\", wiki_content_id, version).first\n end",
"def build_version(new_attrs = {})\n new_version = self.class.new(new_version_attrs(new_attrs)).tap do |built|\n built.deprecate_old_versions_after_create!\n preserve_has_one_associations_to(built) \n end\n end",
"def max_version\n @max_version ||= nil\n end",
"def latest_version\n (Release.where(:manifest_id => manifest_id).max(:version) || 0)\n end",
"def load_version(version)\n if version.is_a?(String)\n if version =~ /^\\d+$/\n version = version.to_i\n else\n version = Time.parse(version)\n end\n elsif version.is_a?(Date)\n Time.parse(version.to_s)\n end\n merged = serialize.tap do |hash|\n versions.select { |h| version.is_a?(Integer) ? h.version >= version : h.created_at > version }\n .sort_by { |h| h.version }.reverse\n .each { |h| hash.deep_merge!(h.changes) }\n end\n self.class.new(merged)\n end",
"def get_prior_version_tag(item)\n ds = item.datastreams['versionMetadata']\n prior_version_id = (Integer(ds.current_version_id) - 1).to_s\n Dor::VersionTag.parse(ds.tag_for_version(prior_version_id))\n end",
"def version_at(timestamp, reify_options = {})\n # Because a version stores how its object looked *before* the change,\n # we need to look for the first version created *after* the timestamp.\n v = versions.subsequent(timestamp, true).first\n return v.reify(reify_options) if v\n @record unless @record.destroyed?\n end",
"def version_at(timestamp, reify_options = {})\n # Because a version stores how its object looked *before* the change,\n # we need to look for the first version created *after* the timestamp.\n v = versions.subsequent(timestamp, true).first\n return v.reify(reify_options) if v\n @record unless @record.destroyed?\n end",
"def full_version\n return nil unless exact\n\n \"~> \".concat(version)\n end",
"def version_number_to_version(version_or_version_number)\n unless version_or_version_number.is_a?(self.class.version_class)\n version_or_version_number = versions.find_by_version(version_or_version_number.to_i)\n end\n version_or_version_number\n end",
"def latest_version\n link = data.xpath(\"at:link[@rel = 'current-version']/@href\", NS::COMBINED)\n if link.first\n entry = conn.get_atom_entry(link.first.text)\n self_or_new(entry)\n else\n # FIXME: should somehow return the current version even for opencmis\n self\n end\n end",
"def <=>(other)\n other_number = other.is_a?(self.class) ? other.number : other\n Gem::Version.new(number) <=> Gem::Version.new(other_number)\n end",
"def revision\n # HEAD is the default, but lets just be explicit here.\n get_revision('HEAD')\n end",
"def minor(version)\n res = 0\n res = Regexp.last_match(1) if version =~ /^\\s*\\d+\\.(\\d+)\\.\\d+/\n res\n end",
"def version\n @version.dup\n end",
"def version\n @version.dup\n end",
"def version(revision_number)\n self.versions.find_by_revision_number(revision_number)\n end",
"def get_latest_revision\n @current_revision\n end",
"def version_number\n if !self.new_quote?\n version = 1\n self.parent_quote.version_quotes.date_created_ordered.each do |quote_instance|\n version +=1\n return \"#{version}.0\" if self.id == quote_instance.id\n end\n end\n '1.0'\n end",
"def version\n '1.5.1.2' # Version number <major>.<minor>.<patch>.<monthly commit>\n end",
"def get_latest_revision\n raise NotImplementedError\n end",
"def latest_version(gem_name, pre: false)\n return versions(gem_name).first if pre\n versions(gem_name).find { |version| !version.prerelease? }\n end",
"def card_version(version_no)\n to_find = if version_no == :latest\n latest_version\n else\n version_no\n end\n card_versions.find_by!(version: to_find)\n end",
"def next_version\n (self.class.directories(original_destination).size + 1).to_s\n end",
"def calculate_versions\n tags = `git for-each-ref --sort='*authordate' --format='%(refname:short)' refs/tags/`.split(\"\\n\")\n @last = tags.select {|l| l =~ /(^#{@prefix}-|\\.0$)/ }.last.gsub(/^#{@prefix}-/, '')\n @current = @last\n\n pemajor, major, minor = @last.split('.')\n minor = minor.to_i + 1\n quarter = major.to_i + 1\n @next = \"#{pemajor}.#{major}.#{minor}\"\n @quarter = \"#{pemajor}.#{quarter}.0\"\nend",
"def latest_version(module_name)\n versions(module_name).last\n end",
"def major_version(full_version)\n full_version.match(/^(\\d+\\.\\d+\\.\\d+)\\.\\d+$/)[1]\n end"
] |
[
"0.72846055",
"0.71790844",
"0.71764606",
"0.71290874",
"0.69964457",
"0.6958",
"0.6955923",
"0.69128436",
"0.6907822",
"0.6838771",
"0.6789951",
"0.6765523",
"0.6760832",
"0.6689323",
"0.6687284",
"0.66861886",
"0.65922624",
"0.6567859",
"0.6558683",
"0.6518475",
"0.6511735",
"0.6505241",
"0.6490083",
"0.6441818",
"0.6438524",
"0.64137405",
"0.63845253",
"0.636403",
"0.63474613",
"0.63433933",
"0.63400257",
"0.6308231",
"0.62981725",
"0.6278139",
"0.6278139",
"0.62768424",
"0.6274914",
"0.62640697",
"0.62604034",
"0.62442935",
"0.623648",
"0.62282866",
"0.6228202",
"0.6213948",
"0.621386",
"0.621386",
"0.62124467",
"0.6204897",
"0.61945087",
"0.6188207",
"0.61881095",
"0.61881095",
"0.6187946",
"0.61777604",
"0.617678",
"0.6173167",
"0.6148031",
"0.6141809",
"0.61267996",
"0.611688",
"0.6113025",
"0.61066145",
"0.6105239",
"0.60830957",
"0.6077759",
"0.60658026",
"0.60542786",
"0.60443074",
"0.6038177",
"0.603305",
"0.6023186",
"0.6010724",
"0.6007367",
"0.60009414",
"0.59987956",
"0.59974027",
"0.5997296",
"0.59959626",
"0.59822327",
"0.5981198",
"0.5979449",
"0.5979449",
"0.5952298",
"0.59492594",
"0.594486",
"0.593349",
"0.59276706",
"0.5923119",
"0.59080416",
"0.59080416",
"0.5906395",
"0.5906279",
"0.5904839",
"0.59033793",
"0.5897501",
"0.5897031",
"0.5894434",
"0.5892926",
"0.58913785",
"0.58857113",
"0.58775926"
] |
0.0
|
-1
|
A Version is only eql? to another version if it's specified to the same precision. Version "1.0" is not the same as version "1".
|
def eql?(other)
self.class === other and @version == other._version
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def test_numeric_comparison\n value1_ = ::Versionomy.create([1, 9, 2], :semver)\n value2_ = ::Versionomy.create([1, 9], :semver)\n assert(value2_ < value1_)\n value1_ = ::Versionomy.create([1, 9, 0], :semver)\n value2_ = ::Versionomy.create([1, 9], :semver)\n assert(value2_ == value1_)\n end",
"def test_numeric_comparison\n value1_ = ::Versionomy.create([1, 9, 2], :rubygems)\n value2_ = ::Versionomy.create([1, 9], :rubygems)\n assert(value2_ < value1_)\n value1_ = ::Versionomy.create([1, 9, 0], :rubygems)\n value2_ = ::Versionomy.create([1, 9], :rubygems)\n assert(value2_ == value1_)\n end",
"def test_equality_simple\n value1_ = ::Versionomy.create(:major => 2, :minor => 0, :release_type => :alpha, :alpha_version => 5)\n value2_ = ::Versionomy.create(:major => 2, :release_type => :alpha, :alpha_version => 5)\n assert_equal(value2_, value1_)\n assert_equal(value2_.hash, value1_.hash)\n end",
"def eql?(other)\n self.class === other and @version == other.version\n end",
"def eql? other\n self.class === other and @version == other.version\n end",
"def == (other)\n Version.compare(self, other) == 0\n end",
"def version_equals?(v1, v2)\n return false unless v1 && v2\n\n v1 == v2\n end",
"def test_comparison_release_type\n value1_ = ::Versionomy.create(:major => 2, :release_type => :alpha, :alpha_version => 5)\n value2_ = ::Versionomy.create(:major => 2, :release_type => :release_candidate, :release_candidate_version => 2)\n assert(value2_ > value1_)\n end",
"def test_equality_parsed\n value1_ = ::Versionomy.parse(\"1.8.7p72\")\n value2_ = ::Versionomy.parse(\"1.8.7.0-72.0\")\n assert_equal(value2_, value1_)\n assert_equal(value2_.hash, value1_.hash)\n end",
"def test_semver_to_standard_equality_comparison\n assert_operator(::Versionomy.parse('1.2.0', :semver), :==, ::Versionomy.parse('1.2'))\n assert_operator(::Versionomy.parse('1.2.0b3', :semver), :==, ::Versionomy.parse('1.2b3'))\n end",
"def test_numeric_and_string_comparison\n value1_ = ::Versionomy.create([1, 9, 2, 'a2'], :semver)\n value2_ = ::Versionomy.create([1, 9, 2], :semver)\n assert(value2_ > value1_)\n end",
"def version_geq(v1, v2)\n version_gt(v1, v2) || !version_gt(v2, v1)\n end",
"def test_numeric_and_string_comparison\n value1_ = ::Versionomy.create([1, 9, 2, 'a', 2], :rubygems)\n value2_ = ::Versionomy.create([1, 9, 2, 1], :rubygems)\n assert(value2_ > value1_)\n end",
"def version_gte?( v1, v2 )\n v1 = version_string_to_a( v1 )\n v2 = version_string_to_a( v2 )\n c = v1 && v2 && ( v1 <=> v2 ) #-> nil for String/Integer mix\n c && c >= 0\n end",
"def ==(other_vector, precision = 6)\n @x.round(precision) == other_vector.x.round(precision) and\n @y.round(precision) == other_vector.y.round(precision)\n end",
"def test_standard_to_semver_equality_comparison\n assert_operator(::Versionomy.parse('1.2.0'), :==, ::Versionomy.parse('1.2.0', :semver))\n assert_operator(::Versionomy.parse('1.2b3'), :==, ::Versionomy.parse('1.2.0beta3', :semver))\n end",
"def test_comparison_minor\n value1_ = ::Versionomy.create(:major => 2, :tiny => 1, :tiny2 => 3, :release_type => :release_candidate, :release_candidate_version => 2)\n value2_ = ::Versionomy.create(:major => 2, :minor => 1, :release_type => :alpha)\n assert(value2_ > value1_)\n end",
"def test_rubygems_to_standard_equality_comparison\n assert_operator(::Versionomy.parse('1.2.0', :rubygems), :==, ::Versionomy.parse('1.2'))\n assert_operator(::Versionomy.parse('1.2.b.3', :rubygems), :==, ::Versionomy.parse('1.2b3'))\n end",
"def test_standard_to_rubygems_equality_comparison\n assert_operator(::Versionomy.parse('1.2.0'), :==, ::Versionomy.parse('1.2', :rubygems))\n assert_operator(::Versionomy.parse('1.2b3'), :==, ::Versionomy.parse('1.2.beta.3', :rubygems))\n end",
"def include?(other)\n cover?(other) && precision == other.precision\n end",
"def test_nonequality_parsed\n value1_ = ::Versionomy.parse(\"1.8.7b7\")\n value2_ = ::Versionomy.parse(\"1.8.7a7\")\n refute_equal(value2_, value1_)\n refute_equal(value2_.hash, value1_.hash)\n end",
"def version_compare(v1, v2)\n gem_v1 = Gem::Version.new(v1.gsub(/\\A\\s*(#{Gem::Version::VERSION_PATTERN}).*/, '\\1'))\n gem_v2 = Gem::Version.new(v2.gsub(/\\A\\s*(#{Gem::Version::VERSION_PATTERN}).*/, '\\1'))\n\n gem_v1 <=> gem_v2\n end",
"def test_semver_to_standard_inequality_comparison\n assert_operator(::Versionomy.parse('1.2.3', :semver), :<, ::Versionomy.parse('1.2.4'))\n assert_operator(::Versionomy.parse('1.2.0b3', :semver), :>, ::Versionomy.parse('1.2b2'))\n assert_operator(::Versionomy.parse('1.2.0', :semver), :>, ::Versionomy.parse('1.2b1'))\n end",
"def version_compare(a, b)\n make_comparable(a) <=> make_comparable(b)\n end",
"def <= (other)\n Version.compare(self, other) <= 0\n end",
"def test_standard_to_semver_inequality_comparison\n assert_operator(::Versionomy.parse('1.2.4'), :>, ::Versionomy.parse('1.2.3', :semver))\n assert_operator(::Versionomy.parse('1.2b2'), :<, ::Versionomy.parse('1.2.0beta3', :semver))\n assert_operator(::Versionomy.parse('1.2b2'), :<, ::Versionomy.parse('1.2.0', :semver))\n end",
"def version_mismatch_detected\n end",
"def test_equality_string\n value1_ = ::Versionomy.parse(\"1.8.7p72\")\n assert_operator(value1_, :==, \"1.8.7p72\")\n assert_operator(value1_, :==, \"1.8.7.0-72.0\")\n end",
"def compare(rhs)\n\n\t\t\t\tif (@major > rhs.major) \n\t\t\t\t\treturn VERSION_LOWER\n\t\t\t\telsif (@major < rhs.major)\n\t\t\t\t\treturn VERSION_GREATER\n\t\t\t\telsif (@minor > rhs.minor) \n\t\t\t\t\treturn VERSION_LOWER\n\t\t\t\telsif (@minor < rhs.minor) \n\t\t\t\t\treturn VERSION_GREATER\n\t\t\t\telsif (@build > rhs.build) \n\t\t\t\t\treturn VERSION_LOWER\n\t\t\t\telsif (@build < rhs.build) \n\t\t\t\t\treturn VERSION_GREATER\n\t\t\t\telse\n\t\t\t\t\treturn VERSION_SAME\n\t\t\t\tend\n\n\t\t\tend",
"def version_gt(v1, v2)\n # Construct an array to make sure the shorter version is padded with nil\n Array.new([v1.length, v2.length].max).zip(v1.split(\".\"), v2.split(\".\")) do |_, p1, p2|\n p1 ||= \"0\"\n p2 ||= \"0\"\n release1 = p1 =~ /^[0-9]+$/\n release2 = p2 =~ /^[0-9]+$/\n if release1 && release2\n # Integer comparison if both are full releases\n p1, p2 = p1.to_i, p2.to_i\n next if p1 == p2\n return p1 > p2\n elsif !release1 && !release2\n # String comparison if both are prereleases\n next if p1 == p2\n return p1 > p2\n else\n # If only one is a release, that one is newer\n return release1\n end\n end\n end",
"def v1_older_v2(v1=\"0.0.0_0\", v2=\"0.0.0_0\")\n v1_n = version_split(v1)\n v2_n = version_split(v2)\n i = 0\n while ( v1_n[i] && v2_n[i] ) do\n if v1_n[i] < v2_n[i]\n return true\n elsif v1_n[i] > v2_n[i]\n return false\n end\n i+=1\n end\n # versions equal case\n return false\n end",
"def older_version v1, v2\n v1 = v1.split('.').map{|s|s.to_i}.extend(Comparable)\n v2 = v2.split('.').map{|s|s.to_i}.extend(Comparable)\n return v1 < v2\n end",
"def ==(other)\n other.name == name and other.version == version\n end",
"def > (other)\n Version.compare(self, other) > 0\n end",
"def >= (other)\n Version.compare(self, other) >= 0\n end",
"def version_lt?( v1, v2 )\n v1 = version_string_to_a( v1 )\n v2 = version_string_to_a( v2 )\n c = v1 && v2 && ( v1 <=> v2 ) #-> nil for String/Integer mix\n c && c < 0\n end",
"def VersionALtB(a_version, b_version)\n a_version_l = Builtins.filter(Builtins.splitstring(a_version, \"-.\")) do |s|\n Builtins.regexpmatch(s, \"^[0123456789]+$\")\n end\n b_version_l = Builtins.filter(Builtins.splitstring(b_version, \"-.\")) do |s|\n Builtins.regexpmatch(s, \"^[0123456789]+$\")\n end\n\n Builtins.y2milestone(\n \"Comparing versions %1 and %2\",\n a_version_l,\n b_version_l\n )\n a_size = Builtins.size(a_version_l)\n b_size = Builtins.size(b_version_l)\n longer_size = Ops.greater_than(a_size, b_size) ? a_size : b_size\n\n b_version_is_newer = false\n compare = 0 # <0 if a<b, =0 if a==b, >0 if a>b\n i = 0\n while Ops.less_than(i, longer_size)\n # -1 will make the desirable outcome of \"2\" < \"2.0\"\n a_item = Builtins.tointeger(Ops.get(a_version_l, i, \"-1\"))\n b_item = Builtins.tointeger(Ops.get(b_version_l, i, \"-1\"))\n if Ops.less_than(a_item, b_item)\n compare = -1\n break\n end\n if Ops.greater_than(a_item, b_item)\n compare = 1\n break\n end\n i = Ops.add(i, 1)\n end\n\n Builtins.y2milestone(\"%1 <=> %2 -> %3\", a_version, b_version, compare)\n Ops.less_than(compare, 0)\n end",
"def compare_version(a, b)\n\n\t\t#split into titl.maj.min.bug.ext\n\t\ta_segments = a.split('.')\n\t\tb_segments = b.split('.')\n\n\t\t#puts a_segments\n\t\t#puts b_segments\n\n\t\t#compare major 1.x.x\n\t\tcase\n\t\twhen a_segments[1].to_i < b_segments[1].to_i\n\t\t\t-1\n\t\twhen a_segments[1].to_i > b_segments[1].to_i\n\t\t\t1\n\t\telse\n\t\t\t#compare minor 1.1.x\n\t\t\tcase\n\t\t\twhen a_segments[2].to_i < b_segments[2].to_i\n\t\t\t-1\n\t\t\twhen a_segments[2].to_i > b_segments[2].to_i\n\t\t\t\t1\n\t\t\telse\n\t\t\t\t#compare point 1.1.1\n\t\t\t\tcase\n\t\t\t\twhen a_segments[3].to_i < b_segments[3].to_i\n\t\t\t\t\t-1\n\t\t\t\twhen a_segments[3].to_i > b_segments[3].to_i\n\t\t\t\t\t1\n\t\t\t\telse\n\t\t\t\t\t0\n\t\t\t\tend\n\t\t\tend\n\t\tend #END comparator\n\tend",
"def !=(other_vector, precision = 6)\n @x.round(precision) != other_vector.x.round(precision) or\n @y.round(precision) != other_vector.y.round(precision)\n end",
"def eql?(other)\n return false unless other.respond_to?(:coords)\n equal = true\n self.coords.each_with_index do |c, i|\n if (c - other.coords.to_a[i])**2 > PRECISION\n equal = false\n break\n end\n end\n equal\n end",
"def test_Complex_InstanceMethods_eql?\n\t\tassert_equal(true, Complex(1,0).eql?(Complex(1,0)))\n\t\tassert_equal(false, Complex(1,0).eql?(Complex(1.0,0)))\n\t\tassert_equal(false, Complex(1,0).eql?(1))\n\t\tassert_equal(true, Complex(1,0) == Complex(1,0))\n\t\tassert_equal(true, Complex(1,0) == Complex(1.0, 0))\n\t\tassert_equal(true, Complex(1,0) == 1)\n\tend",
"def <=>(other)\n @parsed_version <=> other.parsed_version\n end",
"def <=>(other)\n version_number <=> other.version_number\n end",
"def compare_version(remote_version)\n re = /(\\d+)\\./\n remote_version && re.match(remote_version)[1] != re.match(Replica.version)[1] \n end",
"def test_string_comparison\n value1_ = ::Versionomy.create([1, 9, 2, 'a', 2], :rubygems)\n value2_ = ::Versionomy.create([1, 9, 2, 'b', 1], :rubygems)\n assert(value2_ > value1_)\n end",
"def in_same_release_line?(other)\n major == other.major &&\n # minor and patch always match if one or the other is nil (~>-like behavior)\n ( minor.nil? || other.minor.nil? || minor == other.minor ) &&\n ( patch.nil? || other.patch.nil? || patch == other.patch )\n end",
"def <=>(other)\n other_number = other.is_a?(self.class) ? other.number : other\n Gem::Version.new(number) <=> Gem::Version.new(other_number)\n end",
"def <=>(other)\n if @product == other.product\n @version <=> other.version\n else\n false\n end\n end",
"def != (other)\n Version.compare(self, other) != 0\n end",
"def ==(other)\n @klass == other.klass && @version == other.version && @timestamp == other.timestamp\n end",
"def test_standard_to_rubygems_inequality_comparison\n assert_operator(::Versionomy.parse('1.2.4'), :>, ::Versionomy.parse('1.2.3', :rubygems))\n assert_operator(::Versionomy.parse('1.2b2'), :<, ::Versionomy.parse('1.2.beta.3', :rubygems))\n assert_operator(::Versionomy.parse('1.2b2'), :<, ::Versionomy.parse('1.2', :rubygems))\n end",
"def test_rubygems_to_standard_inequality_comparison\n assert_operator(::Versionomy.parse('1.2.3', :rubygems), :<, ::Versionomy.parse('1.2.4'))\n assert_operator(::Versionomy.parse('1.2.b.3', :rubygems), :>, ::Versionomy.parse('1.2b2'))\n assert_operator(::Versionomy.parse('1.2', :rubygems), :>, ::Versionomy.parse('1.2b1'))\n end",
"def test_Rational_InstanceMethods_Compare2\n\t\tassert_equal(true, Rational(\"2\") == Rational(\"2\"))\n\t\tassert_equal(false, Rational(\"1\") == Rational(\"2\"))\n\tend",
"def test_string_comparison\n value1_ = ::Versionomy.create([1, 9, 2, 'a2'], :semver)\n value2_ = ::Versionomy.create([1, 9, 2, 'b1'], :semver)\n assert(value2_ > value1_)\n end",
"def compare_version(v1, v2)\r\n v1 = v1.split('.')\r\n v2 = v2.split('.')\r\n longest = v1.length > v2.length ? v1 : v2\r\n (0...(longest.length)).each do |idx|\r\n one = v1[idx] || '0'\r\n two = v2[idx] || '0'\r\n return -1 if two.to_i > one.to_i\r\n return 1 if one.to_i > two.to_i\r\n end\r\n 0\r\nend",
"def test_comparison_string\n value1_ = ::Versionomy.parse(\"1.8.7p72\")\n assert_operator(value1_, :<, \"1.8.7p73\")\n assert_operator(value1_, :<, \"1.8.8pre1\")\n assert_operator(value1_, :>, \"1.8.7p71\")\n assert_operator(value1_, :>, \"1.8.7rc2\")\n assert_operator(value1_, :>, \"1.8.7.0\")\n end",
"def ==(another_date)\n return false if self.precision != another_date.precision\n self.to_datetime == another_date.to_datetime\n end",
"def mixed_precision?\n min.precision != max.precision\n end",
"def compare_versions(version_a, version_b)\n if version_a == version_b\n return 0\n else\n version_a_d = deconstruct_version_string(version_a)\n version_b_d = deconstruct_version_string(version_b)\n\n if version_a_d[0] > version_b_d[0] ||\n (version_a_d[0] == version_b_d[0] && version_a_d[1] > version_b_d[1]) ||\n (version_a_d[0] == version_b_d[0] && version_a_d[1] == version_b_d[1] && version_a_d[2] > version_b_d[2])\n return 1\n else\n return -1\n end\n end\n end",
"def eql?(p0) end",
"def eql?(p0) end",
"def eql?(p0) end",
"def eql?(p0) end",
"def eql?(p0) end",
"def eql?(p0) end",
"def eql?(p0) end",
"def have_version?(major, minor = nil, update = nil, build = nil)\n if major.class == Float\n major = major.to_s\n end\n if major.class == String\n major,minor,update = major.split('.').collect { |x| x.to_i }\n end\n if major == @major\n return false if minor != nil && minor != @minor\n return false if update != nil && update != @update\n return false if build != nil && build != @build\n return true\n else\n return false\n end\n end",
"def eql? r\n if r.is_a? Ratio\n return (self[0] == r[0] && self[1] == r[1])\n elsif r.is_a? Fixnum\n return (self.to_f == r)\n else\n raise TypeError.new(\"Tried to compare a #{r.class} to an HD::Ratio\")\n end\n end",
"def test_arbitrary_value\n value_ = ::Versionomy.create([1, 9, 2, 'pre2'], :semver)\n assert_equal(1, value_.major)\n assert_equal(9, value_.minor)\n assert_equal(2, value_.patch)\n assert_equal('pre2', value_.prerelease_suffix)\n end",
"def matches?(version_operation)\n pattern_match = version_operation.scan(/\\A([<>]?=?)\\s*(\\d+\\.\\d+)\\z/).first\n fail \"Unsupported comparison operation or version name in #{version_operation.inspect}\" unless pattern_match\n operator, other_version = pattern_match\n operator = '==' if operator.empty? || operator == '='\n send(operator, other_version)\n end",
"def ==(rational)\n end",
"def ensure_version!(version_number, platform: nil)\n if (e = edit_version(platform: platform))\n if e.version.to_s != version_number.to_s\n # Update an existing version\n e.version = version_number\n e.save!\n return true\n end\n return false\n else\n create_version!(version_number, platform: platform)\n return true\n end\n end",
"def is_less_than_one?\n return TRUE if get_dash_version.match(/^(\\d+)\\.\\d+\\.\\d+/)[1].to_i.zero?\n return FALSE\n end",
"def match?(version)\n return false if version < lower_bound\n return include_lower_bound? if version == lower_bound\n return true if upper_bound.nil?\n return false if version > upper_bound\n return include_upper_bound? if version == upper_bound\n true\n end",
"def test_prerelease?(version)\n !@version.stable? && @version.major == version.major && @version.minor == version.minor && @version.patch == version.patch\n end",
"def ==(f)\n self.toFloat() == f.toFloat()\n end",
"def ==(f)\n self.toFloat() == f.toFloat()\n end",
"def nmap_version_at_least?(test_ver=nil)\n raise ArgumentError, \"Cannot compare a Float, use a String or Integer\" if test_ver.kind_of? Float\n unless test_ver.to_s[/^([0-9]+(\\x2e[0-9]+)?)/n]\n raise ArgumentError, \"Bad Nmap comparison version: #{test_ver.inspect}\"\n end\n test_ver_str = test_ver.to_s\n tnum_arr = $1.split(/\\x2e/n)[0,2].map {|x| x.to_i}\n installed_ver = get_nmap_ver()\n vtag = installed_ver.split[2] # Should be [\"Nmap\", \"version\", \"X.YZTAG\", \"(\", \"http..\", \")\"]\n return false if (vtag.nil? || vtag.empty?)\n return false unless (vtag =~ /^([0-9]+\\x2e[0-9]+)/n) # Drop the tag.\n inum_arr = $1.split(/\\x2e/n)[0,2].map {|x| x.to_i}\n return true if inum_arr[0] > tnum_arr[0]\n return false if inum_arr[0] < tnum_arr[0]\n inum_arr[1].to_i >= tnum_arr[1].to_i\nend",
"def eql?(other)\n return self.to_i == other.to_i && self.usec == other.usec\n end",
"def similar_to?(other)\n return false if [:connect_type, :install_type, :secondary_voltage].any? do |prop|\n self[prop] != other[prop]\n end\n\n # Allow 12.47kV and 12.5kV configurations to be used interchangably\n return false if (self[:primary_voltage].to_i - other[:primary_voltage].to_i).abs > 300\n\n self.phases == other.phases\n end",
"def < (other)\n Version.compare(self, other) < 0\n end",
"def _versioncmp(a, b)\n a, b = a.to_s.split('.'), b.to_s.split('.')\n [a.length, b.length].max.times do |i|\n return -1 if a[i].to_i < b[i].to_i\n return 1 if a[i].to_i > b[i].to_i\n end\n return 0\nend",
"def pkg_version_less(a, b)\n a < b\n end",
"def version_gte_62?\n version >= v62\n end",
"def <=>(version)\n to_i <=> version.to_i\n end",
"def version_check_less_than(version_str_new, version_str_old)\n Gem::Version.new(version_str_old) < Gem::Version.new(version_str_new)\n end",
"def cover?(other)\n return false unless other.respond_to?(:day_precision)\n other = other.day_precision\n min.day_precision! <= other && other <= max.day_precision!\n end",
"def compare_versions(y, partial = false)\n x = self\n\n # compare epoch\n if (x.e.nil? == false && x.e > 0) && y.e.nil?\n return 1\n elsif x.e.nil? && (y.e.nil? == false && y.e > 0)\n return -1\n elsif x.e.nil? == false && y.e.nil? == false\n if x.e < y.e\n return -1\n elsif x.e > y.e\n return 1\n end\n end\n\n # compare version\n if partial && (x.v.nil? || y.v.nil?)\n return 0\n elsif x.v.nil? == false && y.v.nil?\n return 1\n elsif x.v.nil? && y.v.nil? == false\n return -1\n elsif x.v.nil? == false && y.v.nil? == false\n cmp = RPMUtils.rpmvercmp(x.v, y.v)\n return cmp if cmp != 0\n end\n\n # compare release\n if partial && (x.r.nil? || y.r.nil?)\n return 0\n elsif x.r.nil? == false && y.r.nil?\n return 1\n elsif x.r.nil? && y.r.nil? == false\n return -1\n elsif x.r.nil? == false && y.r.nil? == false\n cmp = RPMUtils.rpmvercmp(x.r, y.r)\n return cmp\n end\n\n 0\n end",
"def breaking_changes?(version)\n\t\t\tDownloadTV::VERSION.split(\".\").zip(version.split(\".\")).find_index { |x, y| y > x }&.< 2\n\t\tend",
"def <=> (other)\n Version.compare(self, other)\n end",
"def have_at_least_version?(major, minor = nil, update = nil, build = nil)\n if major.class == Float\n major = major.to_s\n end\n if major.class == String\n major,minor,update = major.split('.').collect { |x| x.to_i }\n end\n if major == @major #Could true\n if minor != nil #Being asked to test minor level\n if minor == @minor #Could be true\n if update != nil #Being asked to test update level\n if update == @update #Could be true\n if build != nil #Being asked to test the build version\n return build <= @build #have at least the required patch level.\n end\n return true #update was equal\n end\n return update < @update #current version is newer\n end\n return true #major and minor was equal.\n end\n return minor < @minor #true if current version is newer\n end\n return true #major was equal.\n end\n return major < @major #true, if current version is newer\n end",
"def <=>(other)\n return 0 if full == other.full\n return 1 if compare_version(full, 'gt', other.full)\n return -1 if compare_version(full, 'lt', other.full)\n # A version can be stringwise different but have the same weight.\n # Make sure we cover that.\n return 0 if compare_version(full, 'eq', other.full)\n end",
"def ==(other)\n eq(other.parts)\n end",
"def ==(other_currency); end",
"def <=>(other)\n return unless FoobarMod::Version === other\n return 0 if @version == other._version || canonical_segments == other.canonical_segments\n\n lhsegments = canonical_segments\n rhsegments = other.canonical_segments\n\n lhsize = lhsegments.size\n rhsize = rhsegments.size\n limit = (lhsize > rhsize ? lhsize : rhsize) - 1\n\n i = 0\n\n while i <= limit\n lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0\n i += 1\n\n next if lhs == rhs\n return -1 if String === lhs && Numeric === rhs\n return 1 if Numeric === lhs && String === rhs\n\n return lhs <=> rhs\n end\n\n return 0\n end",
"def ==(other)\n a, b = self.to_f, other.to_f\n a == b\n end",
"def test_dates_with_exact_attributes_are_equal\n assert_equal CarbonDate::Date.new(1988, 7, 11, 6, 43, 3, precision: :second), CarbonDate::Date.new(1988, 7, 11, 6, 43, 3, precision: :second)\n end",
"def verify_version(wrap_op = true)\n model = Sketchup.active_model\n mvers = model.get_attribute('MSPhysics', 'Version')\n cvers = MSPhysics::VERSION\n cver = cvers.gsub(/\\./, '').to_i\n bmake_compatible = false\n if mvers.is_a?(String)\n mver = mvers.gsub(/\\./, '').to_i\n if mver == cver\n return true\n elsif mver < cver\n bmake_compatible = true\n elsif mver > cver\n return false if ::UI.messagebox(\"This model was created with MSPhysics #{mvers}. Your version is #{cvers}. Using an outdated version may result in an improper behaviour! Would you like to continue?\", MB_YESNO) == IDNO\n end\n end\n te = nil\n model.entities.each { |e|\n if e.is_a?(Sketchup::Text) && e.get_attribute('MSPhysics', 'Name') == 'Version Text'\n te = e\n break\n end\n }\n if wrap_op\n op = 'MSPhysics - Utilizing Version'\n Sketchup.version.to_i > 6 ? model.start_operation(op, true, false, false) : model.start_operation(op)\n end\n make_compatible(false) if bmake_compatible\n if te\n te.set_text(\"Created with MSPhysics #{cvers}\\n#{te.text}\")\n else\n te = add_watermark_text(10, 10, \"Created with MSPhysics #{cvers}\", 'Version Text')\n end\n model.set_attribute('MSPhysics', 'Version', cvers)\n model.commit_operation if wrap_op\n true\n end",
"def equal?(p0) end"
] |
[
"0.7103037",
"0.7078211",
"0.6941951",
"0.6727643",
"0.67072713",
"0.66723233",
"0.65382963",
"0.6410356",
"0.6392189",
"0.6389098",
"0.6383337",
"0.6361635",
"0.63400555",
"0.6337259",
"0.63070583",
"0.62533575",
"0.6225545",
"0.62221724",
"0.6147567",
"0.6132779",
"0.6128365",
"0.60464287",
"0.6044526",
"0.6020608",
"0.6017444",
"0.5996344",
"0.5991753",
"0.59565705",
"0.59487253",
"0.59415466",
"0.5903008",
"0.5902881",
"0.58997333",
"0.5872658",
"0.5869044",
"0.58523196",
"0.5844961",
"0.5837656",
"0.5821673",
"0.58162135",
"0.5801943",
"0.57953376",
"0.57952565",
"0.5794185",
"0.579139",
"0.57880354",
"0.5785278",
"0.57775277",
"0.5777391",
"0.577251",
"0.5759858",
"0.5748185",
"0.5678816",
"0.5674456",
"0.56427246",
"0.5637674",
"0.5629173",
"0.5602974",
"0.5596811",
"0.5591435",
"0.5591435",
"0.5591435",
"0.5591435",
"0.5590224",
"0.5590224",
"0.5590224",
"0.5575788",
"0.5573235",
"0.55415076",
"0.553559",
"0.55248576",
"0.5508843",
"0.5507438",
"0.55059516",
"0.5484295",
"0.5479848",
"0.5479848",
"0.5478946",
"0.54767257",
"0.5471354",
"0.5470978",
"0.54707247",
"0.5466905",
"0.5463148",
"0.5441128",
"0.5432755",
"0.542414",
"0.5417278",
"0.5410778",
"0.540976",
"0.5404482",
"0.54022413",
"0.5401782",
"0.5388281",
"0.5379163",
"0.53722745",
"0.5367147",
"0.53635705",
"0.53560054"
] |
0.67370516
|
4
|
A recommended version for use with a ~> Requirement.
|
def approximate_recommendation
segments = self.segments
segments.pop while segments.size > 2
segments.push 0 while segments.size < 2
recommendation = "~> #{segments.join(".")}"
recommendation
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def requirement\n Gem::Requirement.new('~>' + pharos_version.segments.first(2).join('.') + (pharos_version.prerelease? ? '.0-a' : '.0'))\n end",
"def requirement\n \"~> #{major}\"\n end",
"def version\n @dependency.requirement\n end",
"def required_version\n normalize_version(@required_version ||= nil)\n end",
"def required_ruby_version\n spec.required_ruby_version || Gem::Requirement.default\n end",
"def update_twiddle_version(requirement, version_to_be_permitted)\n old_version = requirement.requirements.first.last\n updated_v = at_same_precision(version_to_be_permitted, old_version)\n Gem::Requirement.new(\"~> #{updated_v}\")\n end",
"def updated_gemfile_requirement(req)\n return req unless latest_resolvable_version\n return req if existing_version && no_change_in_version?\n return req if !existing_version && new_version_satisfies?(req)\n\n requirements =\n req[:requirement].split(\",\").map { |r| Gem::Requirement.new(r) }\n\n new_req =\n if requirements.any?(&:exact?)\n \"= #{latest_resolvable_version}\"\n elsif requirements.any? { |r| r.to_s.start_with?(\"~>\") }\n tw_req = requirements.find { |r| r.to_s.start_with?(\"~>\") }\n update_twiddle_version(tw_req, latest_resolvable_version).to_s\n else\n update_gemfile_range(requirements).map(&:to_s).join(\", \")\n end\n\n req.merge(requirement: new_req)\n end",
"def require_version(name, current, required)\n print \"Checking for #{name} >= #{required}... \"\n\n if version_greater_than(current, required)\n puts 'yes'\n else\n abort 'no'\n end\n end",
"def full_version\n return nil unless exact\n\n \"~> \".concat(version)\n end",
"def version_constraint(gem_name); end",
"def latest_version?\n @requirement.none?\n end",
"def latest_version?\n @requirement.none?\n end",
"def default_version; end",
"def find_recommended_require_version(package)\n version = package.version\n unless package.is_dev?\n return transform_version(version, package.pretty_version, package.stability)\n end\n\n loader = ::Composer::Package::Loader::HashLoader.new(parser)\n dumper = ::Composer::Package::Dumper::HashDumper.new\n\n extra = loader.get_branch_alias(dumper.dump(package))\n if extra =~ /^(\\d+\\.\\d+\\.\\d+)(\\.9999999)-dev$/\n extra = \"#{$1}.0\"\n extra.gsub!('.9999999', '.0')\n return transform_version(extra, extra, 'dev')\n end\n\n package.pretty_version\n end",
"def required_version\n versions.find { |v| dependency.match?(name, v) } ||\n raise(Informative, \"Required version (#{dependency}) not found for `#{name}'.\\nAvailable versions: #{versions.join(', ')}\")\n end",
"def get_requirement_version(package_name)\n requirement = File.read(\"requirements/#{package_name}.txt\").strip\n requirement.delete_prefix(\"#{package_name}==\")\nend",
"def required_rubygems_version\n spec.required_rubygems_version || Gem::Requirement.default\n end",
"def required_ruby_version\n spec.required_ruby_version\n end",
"def update_greatest_version(requirement, version_to_be_permitted)\n if version_to_be_permitted.is_a?(String)\n version_to_be_permitted =\n Gem::Version.new(version_to_be_permitted)\n end\n op, version = requirement.requirements.first\n version = version.release if version.prerelease?\n\n index_to_update =\n version.segments.map.with_index { |seg, i| seg.zero? ? 0 : i }.max\n\n new_segments = version.segments.map.with_index do |_, index|\n if index < index_to_update\n version_to_be_permitted.segments[index]\n elsif index == index_to_update\n version_to_be_permitted.segments[index] + 1\n else 0\n end\n end\n\n Gem::Requirement.new(\"#{op} #{new_segments.join('.')}\")\n end",
"def required_version\n fetch(:chef_version) || nil\n end",
"def min_version\n @min_version ||= nil\n end",
"def restrictive_version_specified_gem?(node); end",
"def required_ruby_version=(req)\n @required_ruby_version = Gem::Requirement.create req\n end",
"def required_rubygems_version\n spec.required_rubygems_version\n end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def gem_version; end",
"def version_required(gem_def)\n return Gem::Dependency.instance_methods.map(&:to_sym).include?(:requirement) ? gem_def.requirement : gem_def.version_requirements\nend",
"def get_version_req(dep)\n req = get_key_or_sym(dep, :version_requirement)\n req ||= get_key_or_sym(dep, :version_range)\n req\n end",
"def target_version; end",
"def installed_version\n raise NotImplementedError\n end",
"def version\n '1.5.1.2' # Version number <major>.<minor>.<patch>.<monthly commit>\n end",
"def version\n versions.last.miq_semver.split(\".\").first + \".0.0\"\n end",
"def min_licensing_version\n nil\n end",
"def min_licensing_version\n nil\n end",
"def check_version(version, requirement)\n Gem::Requirement.new( requirement ).satisfied_by? Gem::Version.new( version )\n end",
"def has_version?; end",
"def require_matched_dependency_version\n false\n end",
"def version\n @version ||= '1.0'\n end",
"def default_version\n nil\n end",
"def major_version; end",
"def version\n @gemspec.version || @version_helper.to_s\n end",
"def installed_version\n logger.trace(\"#{new_resource} checking package version\")\n current_installed_version\n end",
"def minimum_required_patch_version\n return @minimum_required_patch_version\n end",
"def update_greatest_version(req_string, version_to_be_permitted)\n if version_to_be_permitted.is_a?(String)\n version_to_be_permitted =\n Utils::Python::Version.new(version_to_be_permitted)\n end\n version = Utils::Python::Version.new(req_string.gsub(/<=?/, \"\"))\n version = version.release if version.prerelease?\n\n index_to_update =\n version.segments.map.with_index { |seg, i| seg.zero? ? 0 : i }.max\n\n new_segments = version.segments.map.with_index do |_, index|\n if index < index_to_update\n version_to_be_permitted.segments[index]\n elsif index == index_to_update\n version_to_be_permitted.segments[index] + 1\n else 0\n end\n end\n\n new_segments.join(\".\")\n end",
"def def_version; end",
"def version\n raise NotImplementedError\n end",
"def version\n raise NotImplementedError\n end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version; end",
"def version\n \"0.2.0\"\n end",
"def version\n @version ||= if token.nil? || Array(packages).empty?\n '0.1.0'\n else\n packages.map do |p|\n Gem::Version.new(p['version'])\n end.sort.last.bump.to_s << '.0'\n end\n end",
"def target_version\n if version_constraint\n solution = self.class.solve_for_constraint(version_constraint, versions)\n \n unless solution\n raise NoSolution, \"No cookbook version of '#{name}' found at #{self} that would satisfy constraint (#{version_constraint}).\"\n end\n\n solution\n else\n latest_version\n end\n end",
"def requires\n self.class::Requirements[@version] || self.class::Requirements[:all] || {}\n end",
"def requirement\n return @requirement if defined?(@requirement) and @requirement\n\n # @version_requirements and @version_requirement are legacy ivar\n # names, and supported here because older gems need to keep\n # working and Dependency doesn't implement marshal_dump and\n # marshal_load. In a happier world, this would be an\n # attr_accessor. The horrifying instance_variable_get you see\n # below is also the legacy of some old restructurings.\n #\n # Note also that because of backwards compatibility (loading new\n # gems in an old RubyGems installation), we can't add explicit\n # marshaling to this class until we want to make a big\n # break. Maybe 2.0.\n #\n # Children, define explicit marshal and unmarshal behavior for\n # public classes. Marshal formats are part of your public API.\n\n # REFACTOR: See above\n\n if defined?(@version_requirement) && @version_requirement\n version = @version_requirement.instance_variable_get :@version\n @version_requirement = nil\n @version_requirements = Gem::Requirement.new version\n end\n\n @requirement = @version_requirements if defined?(@version_requirements)\n end",
"def update_necessary?\n load_mixlib_versioning\n cur_version = Mixlib::Versioning.parse(current_version)\n des_version = Mixlib::Versioning.parse(desired_version)\n Chef::Log.debug(\"The current chef-client version is #{cur_version} and the desired version is #{desired_version}\")\n new_resource.prevent_downgrade ? (des_version > cur_version) : (des_version != cur_version)\nend",
"def installed_version\n capture(\"#{chef_solo} -v || true\") =~ /Chef: (\\d+\\.\\d+\\.\\d+)/ ? $1 : nil\n end",
"def requires_version(cmd, version_)\n v = check_version(version_)\n unless v[0]\n raise NoMethodError, format('%s is not supported in Bugzilla %s', cmd, v[1])\n end\n end",
"def version\n '2.0.7.7' # Version number <major-update>.<minor-update>.<patch-update>.<commit-count>\n end",
"def satisfied_by?(req_vers, new_vers)\n req = LibGems::Requirement.new(req_vers)\n req_vers.sub(/^= /,'') == new_vers.sub(/^= /,'') ||\n req.satisfied_by?(LibGems::Version.new(new_vers))\n end",
"def default_value_for_version\n positional_match_or_nil(@chunked_source.readme, VERSION_MATCH, 2) do |str|\n warn(\"Using version from README: #{str}\")\n end\n end",
"def version\n spec.version\n end",
"def version\n puts \"v0.3\"\n end",
"def version_specified_gem?(node); end",
"def earliest_version_matching(dep)\n version = versions_matching(dep).collect { |v| ::Gem::Version.new v }.min\n version.nil? ? nil : version.to_s\n end",
"def required_rubygems_version=(req)\n @required_rubygems_version = Gem::Requirement.create req\n end",
"def version(arg = nil)\n set_or_return(:version,\n arg,\n kind_of: String,\n default: 'latest',\n callbacks: {\n \"Valid versions are 'latest' or 'x.y.z'\" =>\n ->(a) { valid_version?(a) }\n })\n end",
"def safe_explicit(version)\n return version if version.to_s == ''\n\n test_version = `bundle #{version} --version`.include?('Could not find command')\n test_version ? '' : version\n end",
"def gem_version_more?(name, version)\n Gem.loaded_specs[name].version >= Gem::Version.new(version)\n end",
"def update_necessary?\n load_mixlib_versioning\n cur_version = Mixlib::Versioning.parse(current_version)\n # we have to \"resolve\" partial versions like \"12\" through mixlib-install before comparing them here\n des_version =\n if new_resource.download_url_override\n # probably in an air-gapped environment.\n Mixlib::Versioning.parse(desired_version)\n else\n Mixlib::Versioning.parse(Array(mixlib_install.artifact_info).first.version)\n end\n Chef::Log.debug(\"The current chef-client version is #{cur_version} and the desired version is #{desired_version}\")\n new_resource.prevent_downgrade ? (des_version > cur_version) : (des_version != cur_version)\nend",
"def version=(version)\n @version = Gem::Version.create(version)\n # skip to set required_ruby_version when pre-released rubygems.\n # It caused to raise CircularDependencyError\n if @version.prerelease? && (@name.nil? || @name.strip != \"rubygems\")\n self.required_rubygems_version = '> 1.3.1'\n end\n invalidate_memoized_attributes\n\n return @version\n end",
"def for_lockfile # :nodoc:\n return if [DefaultRequirement] == @requirements\n\n list = requirements.sort_by do |_, version|\n version\n end.map do |op, version|\n \"#{op} #{version}\"\n end.uniq\n\n \" (#{list.join ', '})\"\n end",
"def pre_0_12?\n VersionRequirement.new('< 0.12.0-alpha').satisfied_by?(version)\n end",
"def target_version=(_arg0); end",
"def v string\n Gem::Version.create string\n end",
"def v string\n Gem::Version.create string\n end",
"def version\n 1\n end"
] |
[
"0.72868747",
"0.7146809",
"0.7003008",
"0.6972227",
"0.69709706",
"0.6815177",
"0.67962575",
"0.670734",
"0.6695623",
"0.66733134",
"0.66620564",
"0.66620564",
"0.6634936",
"0.66155094",
"0.660427",
"0.65951306",
"0.654429",
"0.64922875",
"0.6462626",
"0.6437583",
"0.6396447",
"0.63952005",
"0.63940173",
"0.63909",
"0.63638514",
"0.63638514",
"0.63638514",
"0.63638514",
"0.63638514",
"0.63638514",
"0.6311227",
"0.63009495",
"0.62832946",
"0.6264712",
"0.62557566",
"0.6248615",
"0.6239294",
"0.6239294",
"0.62366766",
"0.6229521",
"0.61642087",
"0.61478424",
"0.6128878",
"0.61196184",
"0.6110432",
"0.6104951",
"0.6098773",
"0.6074994",
"0.6066823",
"0.6062515",
"0.6062515",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6057836",
"0.6039664",
"0.6039549",
"0.60243696",
"0.6010686",
"0.6009326",
"0.60025465",
"0.599621",
"0.5991851",
"0.59904987",
"0.59881246",
"0.5979068",
"0.5976616",
"0.59680384",
"0.5961003",
"0.59591573",
"0.5955918",
"0.5951002",
"0.59369516",
"0.5936001",
"0.5935364",
"0.593224",
"0.5931632",
"0.59262204",
"0.5905456",
"0.5894223",
"0.5894223",
"0.589389"
] |
0.0
|
-1
|
Compares this version with +other+ returning 1, 0, or 1 if the other version is larger, the same, or smaller than this one. Attempts to compare to something that's not a Gem::Version return +nil+.
|
def <=>(other)
return unless FoobarMod::Version === other
return 0 if @version == other._version || canonical_segments == other.canonical_segments
lhsegments = canonical_segments
rhsegments = other.canonical_segments
lhsize = lhsegments.size
rhsize = rhsegments.size
limit = (lhsize > rhsize ? lhsize : rhsize) - 1
i = 0
while i <= limit
lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0
i += 1
next if lhs == rhs
return -1 if String === lhs && Numeric === rhs
return 1 if Numeric === lhs && String === rhs
return lhs <=> rhs
end
return 0
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def <=>(other)\n other_number = other.is_a?(self.class) ? other.number : other\n Gem::Version.new(number) <=> Gem::Version.new(other_number)\n end",
"def >= (other)\n Version.compare(self, other) >= 0\n end",
"def <=>(other_version)\n self < other_version ? -1 : self == other_version ? 0 : 1\n end",
"def <= (other)\n Version.compare(self, other) <= 0\n end",
"def < (other)\n Version.compare(self, other) < 0\n end",
"def <=>(other) \n\n versionComparison = Substring.new(get_version_string) <=> Substring.new(other.get_version_string)\n (return versionComparison) if versionComparison != 0\n\n other_pre = other.instance_variable_get('@pre')\n if @pre != nil and other_pre == nil\n return -1\n elsif @pre == nil and other_pre != nil\n return 1\n elsif @pre != nil and other_pre != nil\n pre_comparison = Substring.new(@pre) <=> Substring.new(other_pre)\n (return pre_comparison) if pre_comparison != 0\n end\n\n other_build = other.instance_variable_get('@build')\n if @build == nil and other_build != nil\n return -1\n elsif @build != nil and other_build == nil\n return 1\n elsif @build != nil and other_build != nil\n build_comparison = Substring.new(@build) <=> Substring.new(other_build)\n (return build_comparison) if build_comparison != 0\n end\n\n return 0\n end",
"def == (other)\n Version.compare(self, other) == 0\n end",
"def version_compare(v1, v2)\n gem_v1 = Gem::Version.new(v1.gsub(/\\A\\s*(#{Gem::Version::VERSION_PATTERN}).*/, '\\1'))\n gem_v2 = Gem::Version.new(v2.gsub(/\\A\\s*(#{Gem::Version::VERSION_PATTERN}).*/, '\\1'))\n\n gem_v1 <=> gem_v2\n end",
"def > (other)\n Version.compare(self, other) > 0\n end",
"def <=> (other)\n # Check major version\n cmp = (@major <=> other.major)\n return cmp unless cmp == 0\n\n # Check minor version\n cmp = (@minor <=> other.minor)\n return cmp unless cmp == 0\n\n # Check patch version\n cmp = (@patch <=> other.patch)\n return cmp unless cmp == 0\n\n # Check prerelease arrays\n myown_pre = self.prerelease.split('.')\n convert_to_integer(myown_pre)\n other_pre = other.prerelease.split('.')\n convert_to_integer(other_pre)\n cmp = compare_arrays(myown_pre, other_pre)\n \n # Make sure that the prerelease is compared correctly\n cmp = 1 if cmp == -1 and myown_pre.length == 0\n cmp = -1 if cmp == 1 and other_pre.length == 0\n return cmp unless cmp == 0\n\n # Check build arrays, but only if specified\n # As with the parser, leave identifiers as strings so they can\n # be compared lexically\n if (@@compare_build)\n myown_bld = self.build.split('.')\n other_bld = other.build.split('.')\n cmp = compare_arrays(myown_bld, other_bld)\n return cmp unless cmp == 0\n end\n\n return 0\n end",
"def compare(rhs)\n\n\t\t\t\tif (@major > rhs.major) \n\t\t\t\t\treturn VERSION_LOWER\n\t\t\t\telsif (@major < rhs.major)\n\t\t\t\t\treturn VERSION_GREATER\n\t\t\t\telsif (@minor > rhs.minor) \n\t\t\t\t\treturn VERSION_LOWER\n\t\t\t\telsif (@minor < rhs.minor) \n\t\t\t\t\treturn VERSION_GREATER\n\t\t\t\telsif (@build > rhs.build) \n\t\t\t\t\treturn VERSION_LOWER\n\t\t\t\telsif (@build < rhs.build) \n\t\t\t\t\treturn VERSION_GREATER\n\t\t\t\telse\n\t\t\t\t\treturn VERSION_SAME\n\t\t\t\tend\n\n\t\t\tend",
"def <=> (other)\n Version.compare(self, other)\n end",
"def <=>(other)\n version_number <=> other.version_number\n end",
"def version_compare(a, b)\n make_comparable(a) <=> make_comparable(b)\n end",
"def <=>(other)\n return 0 if full == other.full\n return 1 if compare_version(full, 'gt', other.full)\n return -1 if compare_version(full, 'lt', other.full)\n # A version can be stringwise different but have the same weight.\n # Make sure we cover that.\n return 0 if compare_version(full, 'eq', other.full)\n end",
"def <=>(other)\n case other\n when Gem::Source::Git,\n Gem::Source::Lock,\n Gem::Source::Vendor then\n -1\n when Gem::Source::Installed then\n 0\n when Gem::Source then\n 1\n else\n nil\n end\n end",
"def <=>(other)\n return self <=> self.class.new(other) if (String === other) && self.class.correct?(other)\n\n return unless Gem::Version === other\n return 0 if @version == other._version || canonical_segments == other.canonical_segments\n\n lhsegments = canonical_segments\n rhsegments = other.canonical_segments\n\n lhsize = lhsegments.size\n rhsize = rhsegments.size\n limit = (lhsize > rhsize ? lhsize : rhsize) - 1\n\n i = 0\n\n while i <= limit\n lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0\n i += 1\n\n next if lhs == rhs\n return -1 if String === lhs && Numeric === rhs\n return 1 if Numeric === lhs && String === rhs\n\n return lhs <=> rhs\n end\n\n return 0\n end",
"def <=>(other)\n @parsed_version <=> other.parsed_version\n end",
"def is?(other = nil)\n if other\n RubyVersion == other\n else\n RubyVersion\n end\n end",
"def version_lt?( v1, v2 )\n v1 = version_string_to_a( v1 )\n v2 = version_string_to_a( v2 )\n c = v1 && v2 && ( v1 <=> v2 ) #-> nil for String/Integer mix\n c && c < 0\n end",
"def compare_versions(version_a, version_b)\n if version_a == version_b\n return 0\n else\n version_a_d = deconstruct_version_string(version_a)\n version_b_d = deconstruct_version_string(version_b)\n\n if version_a_d[0] > version_b_d[0] ||\n (version_a_d[0] == version_b_d[0] && version_a_d[1] > version_b_d[1]) ||\n (version_a_d[0] == version_b_d[0] && version_a_d[1] == version_b_d[1] && version_a_d[2] > version_b_d[2])\n return 1\n else\n return -1\n end\n end\n end",
"def <=>(other)\n case other\n when Gem::Source::Installed,\n Gem::Source::Lock then\n -1\n when Gem::Source::Local then\n 0\n when Gem::Source then\n 1\n else\n nil\n end\n end",
"def eql? other\n self.class === other and @version == other.version\n end",
"def version_gt(v1, v2)\n # Construct an array to make sure the shorter version is padded with nil\n Array.new([v1.length, v2.length].max).zip(v1.split(\".\"), v2.split(\".\")) do |_, p1, p2|\n p1 ||= \"0\"\n p2 ||= \"0\"\n release1 = p1 =~ /^[0-9]+$/\n release2 = p2 =~ /^[0-9]+$/\n if release1 && release2\n # Integer comparison if both are full releases\n p1, p2 = p1.to_i, p2.to_i\n next if p1 == p2\n return p1 > p2\n elsif !release1 && !release2\n # String comparison if both are prereleases\n next if p1 == p2\n return p1 > p2\n else\n # If only one is a release, that one is newer\n return release1\n end\n end\n end",
"def pkg_version_less(a, b)\n a < b\n end",
"def >=(other)\n cmp = self.<=>(other)\n cmp == 1 || cmp.zero?\n end",
"def version_gte?( v1, v2 )\n v1 = version_string_to_a( v1 )\n v2 = version_string_to_a( v2 )\n c = v1 && v2 && ( v1 <=> v2 ) #-> nil for String/Integer mix\n c && c >= 0\n end",
"def ==(other)\n other.name == name and other.version == version\n end",
"def _versioncmp(a, b)\n a, b = a.to_s.split('.'), b.to_s.split('.')\n [a.length, b.length].max.times do |i|\n return -1 if a[i].to_i < b[i].to_i\n return 1 if a[i].to_i > b[i].to_i\n end\n return 0\nend",
"def eql?(other)\n self.class === other and @version == other._version\n end",
"def eql?(other)\n self.class === other and @version == other._version\n end",
"def version_greater_than(left, right)\n return Gem::Version.new(left) >= Gem::Version.new(right)\n end",
"def compare_versions(y, partial = false)\n x = self\n\n # compare epoch\n if (x.e.nil? == false && x.e > 0) && y.e.nil?\n return 1\n elsif x.e.nil? && (y.e.nil? == false && y.e > 0)\n return -1\n elsif x.e.nil? == false && y.e.nil? == false\n if x.e < y.e\n return -1\n elsif x.e > y.e\n return 1\n end\n end\n\n # compare version\n if partial && (x.v.nil? || y.v.nil?)\n return 0\n elsif x.v.nil? == false && y.v.nil?\n return 1\n elsif x.v.nil? && y.v.nil? == false\n return -1\n elsif x.v.nil? == false && y.v.nil? == false\n cmp = RPMUtils.rpmvercmp(x.v, y.v)\n return cmp if cmp != 0\n end\n\n # compare release\n if partial && (x.r.nil? || y.r.nil?)\n return 0\n elsif x.r.nil? == false && y.r.nil?\n return 1\n elsif x.r.nil? && y.r.nil? == false\n return -1\n elsif x.r.nil? == false && y.r.nil? == false\n cmp = RPMUtils.rpmvercmp(x.r, y.r)\n return cmp\n end\n\n 0\n end",
"def <=>(other)\n case other\n when Gem::Source::SpecificFile then\n return nil if @spec.name != other.spec.name\n\n @spec.version <=> other.spec.version\n else\n super\n end\n end",
"def != (other)\n Version.compare(self, other) != 0\n end",
"def <=> other\n return unless Vendor::Version === other\n return 0 if @version == other.version\n\n lhsegments = segments\n rhsegments = other.segments\n\n lhsize = lhsegments.size\n rhsize = rhsegments.size\n limit = (lhsize > rhsize ? lhsize : rhsize) - 1\n\n i = 0\n\n while i <= limit\n lhs, rhs = lhsegments[i] || 0, rhsegments[i] || 0\n i += 1\n\n next if lhs == rhs\n return -1 if String === lhs && Numeric === rhs\n return 1 if Numeric === lhs && String === rhs\n\n return lhs <=> rhs\n end\n\n return 0\n end",
"def compare_version(a, b)\n\n\t\t#split into titl.maj.min.bug.ext\n\t\ta_segments = a.split('.')\n\t\tb_segments = b.split('.')\n\n\t\t#puts a_segments\n\t\t#puts b_segments\n\n\t\t#compare major 1.x.x\n\t\tcase\n\t\twhen a_segments[1].to_i < b_segments[1].to_i\n\t\t\t-1\n\t\twhen a_segments[1].to_i > b_segments[1].to_i\n\t\t\t1\n\t\telse\n\t\t\t#compare minor 1.1.x\n\t\t\tcase\n\t\t\twhen a_segments[2].to_i < b_segments[2].to_i\n\t\t\t-1\n\t\t\twhen a_segments[2].to_i > b_segments[2].to_i\n\t\t\t\t1\n\t\t\telse\n\t\t\t\t#compare point 1.1.1\n\t\t\t\tcase\n\t\t\t\twhen a_segments[3].to_i < b_segments[3].to_i\n\t\t\t\t\t-1\n\t\t\t\twhen a_segments[3].to_i > b_segments[3].to_i\n\t\t\t\t\t1\n\t\t\t\telse\n\t\t\t\t\t0\n\t\t\t\tend\n\t\t\tend\n\t\tend #END comparator\n\tend",
"def sim_list_compare(other)\n return os_name.to_s <=> other.os_name.to_s unless os_name == other.os_name\n return other.os_version <=> os_version unless os_version == other.os_version\n device1, model1 = device_and_model\n device2, model2 = other.device_and_model\n return device_compare(device1, device2) unless device1 == device2\n return model1 <=> model2 unless model1.nil? || model2.nil?\n model2.nil? ? 1 : -1\n end",
"def semver_cmp( semver1, semver2 )\n semver_to_i(semver1) - semver_to_i(semver2)\n end",
"def eql?(other)\n self.class === other and @version == other.version\n end",
"def <=>(other)\n unless other.is_a?(self.class)\n other = self.class.new(other)\n end\n if (ret = @major <=> other.major) == 0\n return @minor <=> other.minor\n end\n return ret\n end",
"def <=>(other)\n if @product == other.product\n @version <=> other.version\n else\n false\n end\n end",
"def compare_versions(first, second)\n raise ArgumentError, \"bad version format, version=#{first}\" unless first =~ Orientdb4r::Client::SERVER_VERSION_PATTERN\n raise ArgumentError, \"bad version format, version=#{second}\" unless second =~ Orientdb4r::Client::SERVER_VERSION_PATTERN\n\n firstv = /^(?:(\\d+)\\.)?(?:(\\d+)\\.)?(\\*|\\d+)/.match(first)[0]\n secondv = /^(?:(\\d+)\\.)?(?:(\\d+)\\.)?(\\*|\\d+)/.match(second)[0]\n\n rslt = 0\n rslt = 1 if firstv > secondv\n rslt = -1 if firstv < secondv\n\n yield rslt if block_given?\n\n rslt\n end",
"def version_check_less_than(version_str_new, version_str_old)\n Gem::Version.new(version_str_old) < Gem::Version.new(version_str_new)\n end",
"def >= other\n cmp = self <=> other\n if cmp.nil?\n raise ArgumentError, \"comparison of #{self.class} with #{other.class} failed\"\n end\n cmp >= 0\n end",
"def <=>(other)\n case other\n when Gem::Source::Installed,\n Gem::Source::Local,\n Gem::Source::Lock,\n Gem::Source::SpecificFile,\n Gem::Source::Git,\n Gem::Source::Vendor then\n -1\n when Gem::Source then\n if !@uri\n return 0 unless other.uri\n return 1\n end\n\n return -1 if !other.uri\n\n # Returning 1 here ensures that when sorting a list of sources, the\n # original ordering of sources supplied by the user is preserved.\n return 1 unless @uri.to_s == other.uri.to_s\n\n 0\n else\n nil\n end\n end",
"def <=>(other)\n return 0 if @revision.nil? || other.revision.nil?\n @revision <=> other.revision\n end",
"def ==(other)\n @klass == other.klass && @version == other.version && @timestamp == other.timestamp\n end",
"def <=>(other)\n raise TypeError unless other.is_a?(Version)\n raise DifferentAgentsNotComparable, \"Cannot compare #{@name} and #{other.name}\" unless @name == other.name\n i_sort(other)\n end",
"def version_geq(v1, v2)\n version_gt(v1, v2) || !version_gt(v2, v1)\n end",
"def ==(other)\n self.class == other.class && (\n @gem.name == other.gem.name &&\n @gem.version == other.gem.version &&\n @advisory == other.advisory\n )\n end",
"def ==(other)\n return false if !other\n data == other.data && version == other.version\n end",
"def <=(other)\n cmp = self.<=>(other)\n cmp == -1 || cmp.zero?\n end",
"def ver_cmp(version1,version2)\n v_int_lista=version1.split(\".\").map { |x| x.to_i() }\n v_int_listb=version2.split(\".\").map { |x| x.to_i() }\n lena=v_int_lista.length()\n lenb=v_int_listb.length()\n minab=lena<lenb ? lena:lenb\n ii=0\n while(ii<minab)\n if v_int_lista[ii]!=v_int_listb[ii]\n break\n end\n ii=ii+1\n end\n if ii<minab\n then\n return v_int_lista[ii]-v_int_listb[ii]\n elsif ii==minab\n then\n if lena>minab\n then\n return 1\n elsif (lenb > minab)\n then\n return -1\n else\n return v_int_lista[minab-1]-v_int_listb[minab-1]\n end\n end\n return 9999\nend",
"def priority_compare(other)\n pc = simplified <=> other.simplified\n if pc.zero? || !(extensions & other.extensions).empty?\n pc =\n if (reg = registered?) != other.registered?\n reg ? -1 : 1 # registered < unregistered\n elsif (comp = complete?) != other.complete?\n comp ? -1 : 1 # complete < incomplete\n elsif (obs = obsolete?) != other.obsolete?\n obs ? 1 : -1 # current < obsolete\n elsif obs && ((ui = use_instead) != (oui = other.use_instead))\n if ui.nil?\n 1\n elsif oui.nil?\n -1\n else\n ui <=> oui\n end\n else\n 0\n end\n end\n\n pc\n end",
"def priority_compare(other)\n pc = simplified <=> other.simplified\n\n if pc.zero? and registered? != other.registered?\n pc = registered? ? -1 : 1\n end\n\n if pc.zero? and platform? != other.platform?\n pc = platform? ? 1 : -1\n end\n\n if pc.zero? and complete? != other.complete?\n pc = complete? ? -1 : 1\n end\n\n if pc.zero? and obsolete? != other.obsolete?\n pc = obsolete? ? 1 : -1\n end\n\n if pc.zero? and obsolete? and (use_instead != other.use_instead)\n pc = if use_instead.nil?\n -1\n elsif other.use_instead.nil?\n 1\n else\n use_instead <=> other.use_instead\n end\n end\n\n pc\n end",
"def <=>(other)\n \"#{type}#{name}#{version}\" <=> \"#{other.type}#{other.name}#{other.version}\"\n end",
"def older_version v1, v2\n v1 = v1.split('.').map{|s|s.to_i}.extend(Comparable)\n v2 = v2.split('.').map{|s|s.to_i}.extend(Comparable)\n return v1 < v2\n end",
"def test_numeric_comparison\n value1_ = ::Versionomy.create([1, 9, 2], :rubygems)\n value2_ = ::Versionomy.create([1, 9], :rubygems)\n assert(value2_ < value1_)\n value1_ = ::Versionomy.create([1, 9, 0], :rubygems)\n value2_ = ::Versionomy.create([1, 9], :rubygems)\n assert(value2_ == value1_)\n end",
"def > other\n cmp = self <=> other\n if cmp.nil?\n raise ArgumentError, \"comparison of #{self.class} with #{other.class} failed\"\n end\n cmp > 0\n end",
"def ==(other)\n r = true\n [:url, :supported_versions, :salt, :version, :debug].each do |param|\n r = r && self.send(param) == other.send(param)\n end\n r\n end",
"def ==(other)\n r = true\n [:url, :supported_versions, :salt, :version, :debug].each do |param|\n r = r && self.send(param) == other.send(param)\n end\n r\n end",
"def ==(other)\n self.<=>(other).zero?\n end",
"def test_numeric_comparison\n value1_ = ::Versionomy.create([1, 9, 2], :semver)\n value2_ = ::Versionomy.create([1, 9], :semver)\n assert(value2_ < value1_)\n value1_ = ::Versionomy.create([1, 9, 0], :semver)\n value2_ = ::Versionomy.create([1, 9], :semver)\n assert(value2_ == value1_)\n end",
"def <=>(other)\n return 0 if self.equal?(other)\n enum1, enum2 = self.to_enum, other.to_enum\n loop do\n item1 = enum1.next\n item2 = enum2.next\n comp = (item1 <=> item2)\n return comp if comp != 0\n end\n size1, size2 = self.size, other.size\n return 0 if size1 == size2\n size1 > size2 ? 1 : -1\n end",
"def <=>(other)\n return super if !other.is_a?(self.class)\n\n # Comparison is done by composing the name and provider\n \"#{@name}-#{@version}-#{@provider}\" <=>\n \"#{other.name}-#{other.version}-#{other.provider}\"\n end",
"def compare_version(v1, v2)\r\n v1 = v1.split('.')\r\n v2 = v2.split('.')\r\n longest = v1.length > v2.length ? v1 : v2\r\n (0...(longest.length)).each do |idx|\r\n one = v1[idx] || '0'\r\n two = v2[idx] || '0'\r\n return -1 if two.to_i > one.to_i\r\n return 1 if one.to_i > two.to_i\r\n end\r\n 0\r\nend",
"def ==(other)\n (cmp = (self <=> other)) ? cmp.zero? : false\n end",
"def ===(other)\n return nil unless Gem::Platform === other\n\n # cpu\n ([nil,'universal'].include?(@cpu) or [nil, 'universal'].include?(other.cpu) or @cpu == other.cpu or\n (@cpu == 'arm' and other.cpu.start_with?(\"arm\"))) and\n\n # os\n @os == other.os and\n\n # version\n (@version.nil? or other.version.nil? or @version == other.version)\n end",
"def test_numeric_and_string_comparison\n value1_ = ::Versionomy.create([1, 9, 2, 'a', 2], :rubygems)\n value2_ = ::Versionomy.create([1, 9, 2, 1], :rubygems)\n assert(value2_ > value1_)\n end",
"def VersionALtB(a_version, b_version)\n a_version_l = Builtins.filter(Builtins.splitstring(a_version, \"-.\")) do |s|\n Builtins.regexpmatch(s, \"^[0123456789]+$\")\n end\n b_version_l = Builtins.filter(Builtins.splitstring(b_version, \"-.\")) do |s|\n Builtins.regexpmatch(s, \"^[0123456789]+$\")\n end\n\n Builtins.y2milestone(\n \"Comparing versions %1 and %2\",\n a_version_l,\n b_version_l\n )\n a_size = Builtins.size(a_version_l)\n b_size = Builtins.size(b_version_l)\n longer_size = Ops.greater_than(a_size, b_size) ? a_size : b_size\n\n b_version_is_newer = false\n compare = 0 # <0 if a<b, =0 if a==b, >0 if a>b\n i = 0\n while Ops.less_than(i, longer_size)\n # -1 will make the desirable outcome of \"2\" < \"2.0\"\n a_item = Builtins.tointeger(Ops.get(a_version_l, i, \"-1\"))\n b_item = Builtins.tointeger(Ops.get(b_version_l, i, \"-1\"))\n if Ops.less_than(a_item, b_item)\n compare = -1\n break\n end\n if Ops.greater_than(a_item, b_item)\n compare = 1\n break\n end\n i = Ops.add(i, 1)\n end\n\n Builtins.y2milestone(\"%1 <=> %2 -> %3\", a_version, b_version, compare)\n Ops.less_than(compare, 0)\n end",
"def <=>(other)\n NAMES.each do |name|\n result = send(name).to_i <=> other.send(name).to_i\n return result unless result.zero?\n end\n\n 0\n end",
"def >= other\n #This is a stub, used for indexing\n end",
"def ==(other)\n result = self <=> other\n result._equal?(nil) ? result : result._equal?(0)\n end",
"def ==(other)\n (self <=> other) == 0\n rescue EnumError\n false\n end",
"def =~(other)\n unless Gem::Dependency === other\n return unless other.respond_to?(:name) && other.respond_to?(:version)\n other = Gem::Dependency.new other.name, other.version\n end\n\n return false unless name === other.name\n\n reqs = other.requirement.requirements\n\n return false unless reqs.length == 1\n return false unless reqs.first.first == '='\n\n version = reqs.first.last\n\n requirement.satisfied_by? version\n end",
"def test_numeric_and_string_comparison\n value1_ = ::Versionomy.create([1, 9, 2, 'a2'], :semver)\n value2_ = ::Versionomy.create([1, 9, 2], :semver)\n assert(value2_ > value1_)\n end",
"def <= other\n cmp = self <=> other\n if cmp.nil?\n raise ArgumentError, \"comparison of #{self.class} with #{other.class} failed\"\n end\n cmp <= 0\n end",
"def <(other)\n self.<=>(other) == -1\n end",
"def == other\n cmp = self <=> other\n cmp == 0\n end",
"def v1_older_v2(v1=\"0.0.0_0\", v2=\"0.0.0_0\")\n v1_n = version_split(v1)\n v2_n = version_split(v2)\n i = 0\n while ( v1_n[i] && v2_n[i] ) do\n if v1_n[i] < v2_n[i]\n return true\n elsif v1_n[i] > v2_n[i]\n return false\n end\n i+=1\n end\n # versions equal case\n return false\n end",
"def >=(other)\r\n Parser.new do |input|\r\n first = run(input)\r\n if first.ok?\r\n second = other.run(first.remaining)\r\n if second.ok?\r\n ParserResult.ok(first.output, matched: first.matched, remaining: second.remaining)\r\n else\r\n first\r\n end\r\n else\r\n ParserResult.fail(input)\r\n end\r\n end\r\n end",
"def <=>(other)\n (year_number <=> other.year_number).nonzero? || month_number <=> other.month_number\n end",
"def compare(v1, v2)\n if v1.value == v2.value\n return 0\n elsif v1.value > v2.value\n return 1\n else\n return -1\n end\n end",
"def <=>(other)\n if to_f < other.to_f\n -1\n elsif to_f > other.to_f\n 1\n else\n 0\n end\n end",
"def <=>(other)\n if comparable_attrs.all? { |attr| send(attr) == other.send(attr) }\n 0\n else\n other.updated_at.blank? || (updated_at < other.updated_at) ? -1 : 1\n end\n end",
"def <=>(other)\n NAMES.each do |name|\n result = send(name).to_i <=> other.send(name).to_i\n return result unless result.zero?\n end\n 0\n end",
"def ==(other)\n return false unless self.class <=> other.class\n cmp?(__method__, other)\n end",
"def secure_compare(other)\n return false unless self.bytesize == other.bytesize\n\n l = self.unpack \"C#{self.bytesize}\"\n\n res = 0\n other.each_byte { |byte| res |= byte ^ l.shift }\n res == 0\n end",
"def version_equals?(v1, v2)\n return false unless v1 && v2\n\n v1 == v2\n end",
"def check_version_conflict(other) # :nodoc:\n return if self.version == other.version\n\n # This gem is already loaded. If the currently loaded gem is not in the\n # list of candidate gems, then we have a version conflict.\n\n msg = \"can't activate #{full_name}, already activated #{other.full_name}\"\n\n e = Gem::LoadError.new msg\n e.name = self.name\n\n raise e\n end",
"def compare_kickers(other)\n kicker_cards.each_with_index do |kicker, i|\n other_kicker = other.kicker_cards[i]\n compared_by_kicker = kicker <=> other_kicker\n return compared_by_kicker unless compared_by_kicker == 0\n end\n 0\n end",
"def compare(one, other)\n other_rem = other.remaining_same_calls\n one_rem = one.remaining_same_calls\n if one_rem == other_rem\n # Note: the line below is correctly reversing the operands\n # This is done to have the larger period ordered before the\n # shorter ones when the remaining hits are the same.\n other.period.granularity <=> one.period.granularity\n elsif other_rem == -1 || one_rem < other_rem\n -1\n else\n 1\n end\n end",
"def <=> other\n (@comparator ||=\n KeyValue.const_defined?(:COMPARATOR) ?\n KeyValue::COMPARATOR : KeyValue.COMPARATOR).compare(@java, other.java)\n end",
"def ==(other)\n lcm_div = @div.lcm(other.div)\n (@val * (lcm_div / @div)) == (other.val * (lcm_div / other.div))\n end",
"def <=>( other )\n\n\t\tif rval = (other.qvalue <=> @qvalue).nonzero?\n\t\t\treturn rval\n\t\tend\n\n\t\tif @type.nil?\n\t\t\treturn 1 if ! other.type.nil?\n\t\telsif other.type.nil?\n\t\t\treturn -1\n\t\tend\n\n\t\tif @subtype.nil?\n\t\t\treturn 1 if ! other.subtype.nil?\n\t\telsif other.subtype.nil?\n\t\t\treturn -1\n\t\tend\n\n\t\tif rval = (other.extensions.length <=> @extensions.length).nonzero?\n\t\t\treturn rval\n\t\tend\n\n\t\treturn self.mediatype <=> other.mediatype\n\tend",
"def <=> other\n if sortable_number.nil? && other.sortable_number.nil?\n 0\n elsif sortable_number.nil?\n -1\n elsif other.sortable_number.nil?\n 1\n else\n self.sortable_number <=> other.sortable_number\n end\n end",
"def <=>(other)\n RubyPython::PyMain.cmp(self, other)\n end",
"def <=>(other)\n if other.nil?\n 1\n else\n self.date <=> other.date\n end\n end",
"def ruby_version?(cmp, v)\n rv = Gem::Version.create(RUBY_VERSION.dup)\n v = Gem::Version.create(v)\n if cmp.to_sym==:'~>'\n rv = rv.release\n rv >= v && rv < v.bump\n else\n rv.send(cmp, v)\n end\n end"
] |
[
"0.7609623",
"0.74609953",
"0.7447309",
"0.732224",
"0.7188725",
"0.71836454",
"0.71729964",
"0.71470916",
"0.7091674",
"0.6997455",
"0.6924706",
"0.6866984",
"0.68485516",
"0.68006617",
"0.67671907",
"0.6677429",
"0.65965027",
"0.656231",
"0.6554482",
"0.65196544",
"0.64849824",
"0.6443158",
"0.64303136",
"0.64293957",
"0.64206666",
"0.6400904",
"0.63767356",
"0.63684094",
"0.63675195",
"0.6336017",
"0.6336017",
"0.63267875",
"0.63241506",
"0.632205",
"0.6317243",
"0.6312219",
"0.6262881",
"0.6222369",
"0.62115234",
"0.6202506",
"0.6201926",
"0.61975175",
"0.61765486",
"0.6167997",
"0.61517054",
"0.6142515",
"0.61136824",
"0.61070323",
"0.6106078",
"0.61058897",
"0.60925615",
"0.60709447",
"0.6066188",
"0.6061966",
"0.60565996",
"0.6018885",
"0.59708756",
"0.5970324",
"0.5959577",
"0.593916",
"0.5923021",
"0.5923021",
"0.5913524",
"0.5906669",
"0.5904185",
"0.59003067",
"0.5898115",
"0.58657515",
"0.58457905",
"0.5825382",
"0.5814235",
"0.58114773",
"0.5811308",
"0.5806332",
"0.5794268",
"0.57823914",
"0.5782359",
"0.57791305",
"0.5699172",
"0.5676051",
"0.56754696",
"0.5667738",
"0.5656716",
"0.56371886",
"0.5631866",
"0.5631537",
"0.5630182",
"0.5626659",
"0.56006217",
"0.55863875",
"0.55773735",
"0.55714333",
"0.55649614",
"0.55505353",
"0.55472916",
"0.5538689",
"0.55234927",
"0.55131847",
"0.54913634",
"0.5488453"
] |
0.6446981
|
21
|
DELETE /social_medias/1 DELETE /social_medias/1.json
|
def destroy
@social_media.destroy
respond_to do |format|
format.html { redirect_to url_back, notice: 'social media was successfully destroyed.' }
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @socialmediasite.destroy\n respond_to do |format|\n format.html { redirect_to socialmediasites_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medio = Medio.find(params[:id])\n @medio.destroy\n\n respond_to do |format|\n format.html { redirect_to medios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @socialmedium = Socialmedium.find(params[:id])\n @socialmedium.destroy\n\n respond_to do |format|\n format.html { redirect_to socialmedia_url }\n format.json { head :no_content }\n end\n end",
"def deleteEntitySocialmedia( entity_id, gen_id)\n params = Hash.new\n params['entity_id'] = entity_id\n params['gen_id'] = gen_id\n return doCurl(\"delete\",\"/entity/socialmedia\",params)\n end",
"def destroy\n @admin_social_medium = Admin::SocialMedium.find(params[:id])\n @admin_social_medium.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_social_media_url }\n format.json { head :ok }\n end\n end",
"def delete_media_by_id id\r\n # the base uri for api requests\r\n query_builder = Configuration.BASE_URI.dup\r\n\r\n # prepare query string for API call\r\n query_builder << \"/media/{id}\"\r\n\r\n # process optional query parameters\r\n query_builder = APIHelper.append_url_with_template_parameters query_builder, {\r\n \"id\" => id,\r\n }\r\n\r\n # validate and preprocess url\r\n query_url = APIHelper.clean_url query_builder\r\n\r\n # prepare headers\r\n headers = {\r\n \"user-agent\" => \"APIMATIC 2.0\",\r\n \"accept\" => \"application/json\",\r\n \"Content-Type\" => Configuration.content_type\r\n }\r\n\r\n # append custom auth authorization\r\n CustomAuthUtility.append_custom_auth_params headers\r\n\r\n # invoke the API call request to fetch the response\r\n response = Unirest.delete query_url, headers:headers\r\n\r\n #Error handling using HTTP status codes\r\n if !(response.code.between?(200,206)) # [200,206] = HTTP OK\r\n raise APIException.new \"HTTP Response Not OK\", response.code, response.raw_body\r\n else \r\n puts \"Media ID Deleted\"\r\n end\r\n\r\n response.body\r\n end",
"def destroy\n @medio = Medio.find(params[:id])\n @medio.destroy\n\n respond_to do |format|\n format.html { redirect_to(medios_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @media = Media.find(params[:id])\n @media.destroy\n\n respond_to do |format|\n format.html { redirect_to(medias_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @medium = Medium.find(params[:id])\n @medium.destroy\n \n respond_to do |format|\n format.html { redirect_to media_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @multimedia = find_media\n @medium = Medium.find(params[:id])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to @multimedia }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium.destroy\n respond_to do |format|\n format.html { redirect_to media_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium = Medium.find(params[:id])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to media_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @media_interest.destroy\n\n respond_to do |format|\n format.html { redirect_to media_interests_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium = Medium.find(params[:id])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to media_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @media_item = MediaItem.find(params[:id])\n @media_item.destroy\n\n respond_to do |format|\n format.html { redirect_to media_items_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @social_media_link.destroy\n\n head :no_content\n end",
"def destroy\n @remedio = Remedio.find(params[:id])\n @remedio.destroy\n\n respond_to do |format|\n format.html { redirect_to remedios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mediaset = Mediaset.find(params[:id])\n @mediaset.destroy\n\n respond_to do |format|\n format.html { redirect_to mediasets_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mediation.destroy\n respond_to do |format|\n format.html { redirect_to mediations_url, notice: 'Mediation was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rede_social.destroy\n respond_to do |format|\n format.html { redirect_to \"/show_rede_social/#{@artist_data.id}/adm/remover\", notice: 'Rede social was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @media_type = MediaType.find(params[:id])\n @media_type.destroy\n\n respond_to do |format|\n format.html { redirect_to media_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @media_item.destroy\n respond_to do |format|\n format.html { redirect_to media_items_url, notice: t('media_items.was_deleted') }\n format.json { head :no_content }\n end\n end",
"def destroy\n @social = Social.find(params[:id])\n @social.destroy\n\n respond_to do |format|\n format.html { redirect_to '/' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @media_path = MediaPath.find(params[:id])\n @media_path.destroy\n\n respond_to do |format|\n format.html { redirect_to({:controller=>:rmedial_settings, :action=>:index}) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @medium = Medium.find_by_local_key(params[:local_key])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to media_url }\n format.json { render json: @medium.item }\n end\n end",
"def destroy\n @social.destroy\n respond_to do |format|\n format.html { redirect_to socials_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium = Media.find(params[:id])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @sample_photo.destroy\n render json: {message: 'Foto Excluida'} , status: :ok\n end",
"def destroy\n @medium = Medium.find(params[:id])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to media_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @medium.destroy\n respond_to do |format|\n format.html { redirect_to media_url, notice: 'Medium was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium.destroy\n respond_to do |format|\n format.html { redirect_to media_url, notice: 'Medium was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium.destroy\n respond_to do |format|\n format.html { redirect_to media_url, notice: 'Medium was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medium.destroy\n respond_to do |format|\n format.html { redirect_to media_url, notice: \"Medium was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @media_share = MediaShare.find(params[:id])\n @media_share.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_shares_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @structure_photo.destroy\n render json: {message: 'Foto Excluida'} , status: :ok\n end",
"def destroy\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to profile_media_path(current_member) }\n format.json { head :no_content }\n format.js\n end\n end",
"def destroy\n @medium = Medium.find(params[:id])\n @medium.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @media_metadata_item = MediaMetadataItems.find(params[:id])\n @media_metadata_item.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_metadata_items_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @media_profile = MediaProfile.find(params[:id])\n @media_profile.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_profiles_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @musica.audios.purge\n @musica.destroy\n respond_to do |format|\n format.html { redirect_to musicas_url, notice: 'Álbum apagado com sucesso!' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @media_item = MediaItem.find(params[:id])\n @media_item.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_items_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @social_networking.destroy\n\n render json: @social_networking, status: :ok\n end",
"def destroy\n @custom_media_entry.destroy\n respond_to do |format|\n format.html { redirect_to custom_media_entries_url, notice: 'Custom media entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @micrrapost = Micrrapost.find(params[:id])\n @micrrapost.destroy\n\n respond_to do |format|\n format.html { redirect_to micrraposts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @metum.destroy\n respond_to do |format|\n format.html { redirect_to meta_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medio_video.destroy\n respond_to do |format|\n format.html { redirect_to medio_videos_url, notice: 'Medio video was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mensagem = Mensagem.find(params[:id])\n api_client.delete_object(@mensagem.post_id)\n @mensagem.destroy\n\n respond_to do |format|\n format.xml { head :ok }\n format.js { head :ok }\n end\n end",
"def destroy\n @media_item = MediaItem.find(params[:id])\n @media_item.destroy\n @project = Project.find(params[:project_id])\n\n respond_to do |format|\n format.html { redirect_to @project, notice: 'Media item was deleted' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @resource = @media_file.resource\n\n @media_file.destroy\n respond_to do |format|\n format.html { redirect_to edit_resource_path(@resource), notice: 'Media was removed.' }\n format.json { head :no_content }\n format.js\n end\n end",
"def destroy\n @medi_session.destroy\n respond_to do |format|\n format.html { redirect_to medi_sessions_url, notice: 'Medi session was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete_media\n media_category = Media.find(params[:id]).media_category_id\n Media.find(params[:id]).destroy\n\n redirect_to media_path(media_category)\n end",
"def destroy\n @unidade_medida = UnidadeMedida.find(params[:id])\n @unidade_medida.destroy\n\n respond_to do |format|\n format.html { redirect_to unidade_medidas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n record = Asset.find(params[:id])\n record.destroy\n\n respond_to do |format| \n format.json { head :no_content }\n end\n end",
"def destroy\n @media_scope.destroy\n\n respond_to do |format|\n format.html { redirect_to media_scopes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n MediaCategory.find(params[:id]).destroy\n\n redirect_to admin_medias_path\n end",
"def delete\n item = FormImage.last\n id = item[:id]\n item.destroy\n render json: {id: id}\n end",
"def destroy\r\n @gallery_activity = GalleryActivity.find(params[:id])\r\n @gallery_activity.destroy\r\n\r\n respond_to do |format|\r\n format.html { redirect_to gallery_activities_url }\r\n format.json { head :ok }\r\n end\r\n end",
"def destroy\n @social_media_account.destroy\n respond_to do |format|\n format.html { redirect_to social_media_accounts_url, notice: 'Social media account was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @momsg = Momsg.find(params[:id])\n @momsg.destroy\n\n respond_to do |format|\n format.html { redirect_to momsgs_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @go_slim = GoSlim.find(params[:id])\n @go_slim.destroy\n\n respond_to do |format|\n format.html { redirect_to go_slims_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medio_pago = MedioPago.find(params[:id])\n @medio_pago.destroy\n\n respond_to do |format|\n format.html { redirect_to medio_pagos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @photo.destroy\n respond_to do |format|\n format.html { redirect_to @photo.item }\n format.json { head :no_content }\n end\n end",
"def destroy\n @metum = Metum.find(params[:id])\n @metum.destroy\n\n respond_to do |format|\n format.html { redirect_to meta_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @media_attribute = MediaAttribute.find(params[:id])\n @media_attribute.destroy\n\n respond_to do |format|\n format.html { redirect_to(media_attributes_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @imagem = Imagem.find(params[:id])\n @imagem.destroy\n\n respond_to do |format|\n format.html { redirect_to imagems_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @relacion_articulo_medida = RelacionArticuloMedida.find(params[:id])\n @relacion_articulo_medida.destroy\n\n respond_to do |format|\n format.html { redirect_to relaciones_articulos_medida_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @med.destroy\n respond_to do |format|\n format.html { redirect_to meds_url, notice: 'Med was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @med.destroy\n respond_to do |format|\n format.html { redirect_to meds_url, notice: 'Med was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @api_v1_news_link_photo.destroy\n respond_to do |format|\n format.html { redirect_to api_v1_news_link_photos_url, notice: 'News link photo was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @shared_url = SharedUrl.find(params[:id])\n @shared_url.destroy\n\n respond_to do |format|\n format.html { redirect_to shared_urls_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @photo = Photo.find(params[:id])\n gallery = @photo.gallery\n @photo.destroy\n\n respond_to do |format|\n format.html { redirect_to gallery_path(gallery) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @retroaspecto = Retroaspecto.find(params[:id])\n @retroaspecto.destroy\n\n respond_to do |format|\n format.html { redirect_to retroaspectos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @custom_medium.destroy\n respond_to do |format|\n format.html { redirect_to custom_media_url, notice: 'Custom medium was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @plsbgmusic_mediafile.destroy\n respond_to do |format|\n format.html { redirect_to plsbgmusic_mediafiles_url, notice: 'Plsbgmusic mediafile was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @midia.destroy\n\n respond_to do |format|\n format.html { redirect_to midias_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ministerio = Ministerio.find(params[:id])\n @ministerio.destroy\n\n respond_to do |format|\n format.html { redirect_to ministerios_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @test_metum.destroy\n respond_to do |format|\n format.html { redirect_to test_meta_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @microsite.destroy\n respond_to do |format|\n format.html { redirect_to microsites_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @facebook_share.destroy\n respond_to do |format|\n format.html { redirect_to facebook_shares_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medalha.destroy\n respond_to do |format|\n format.html { redirect_to medalhas_url, notice: 'Medalha was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @share.destroy\n\n respond_to do |format|\n format.html { redirect_to @redirect_location }\n format.json { head :no_content } \n end\n end",
"def delete\n\n unless params[:id]\n render json: {message: \" اطلاعات را به صورت کامل بفرستید \"}, status: 400\n return\n end\n\n social = @current_user.socials.where( id: params[:id]).last\n\n if social\n if social.destroy\n render json: { message: \" شبکه اجتماعی حذف شد \" } , status: 200\n else\n render json: social.errors , status: 400\n end\n else\n render json: { message: \" شبکه اجتماعی مورد نظر یافت نشد \" } , status: 404\n end\n\n end",
"def destroy\n @loveinstagram.destroy\n respond_to do |format|\n format.html { redirect_to loveinstagrams_url, notice: 'Loveinstagram was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @im.destroy\n respond_to do |format|\n format.html { redirect_to ims_url, notice: 'Im was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete\n render json: Like.delete(params[\"id\"])\n end",
"def destroy\n @photo = Photo.find(params[:id])\n @photo.destroy\n\n respond_to do |format|\n format.html { redirect_to uploads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rock_photo.destroy\n render json: {message: 'Foto Excluida'} , status: :ok\n end",
"def destroy\n @gallery = Gallery.find(params[:id])\n\n begin\n AWS::S3::S3Object.find(@gallery.thumbnail, @@BUCKET).delete\n rescue Exception=>e\n # handle e\n end\n \n @gallery.destroy\n\n respond_to do |format|\n format.html { redirect_to galleries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medicamento = Medicamento.find(params[:id])\n @medicamento.destroy\n\n respond_to do |format|\n format.html { redirect_to medicamentos_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @micorpost = Micorpost.find(params[:id])\n @micorpost.destroy\n\n respond_to do |format|\n format.html { redirect_to micorposts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @medzz = Medzz.find(params[:id])\n @medzz.destroy\n\n respond_to do |format|\n format.html { redirect_to medzzs_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @externalformlink.destroy\n respond_to do |format|\n format.html { redirect_to externalformlinks_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @micrropost = Micrropost.find(params[:id])\n @micrropost.destroy\n\n respond_to do |format|\n format.html { redirect_to micrroposts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @avatar.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @intermediary = Intermediary.find(params[:id])\n @intermediary.destroy\n\n respond_to do |format|\n format.html { redirect_to intermediaries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @mou.destroy\n respond_to do |format|\n format.html { redirect_to mous_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @photo.destroy\n respond_to do |format|\n format.html { redirect_to uploads_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mfile = Mfile.find(params[:id])\n @mfile.destroy\n\n respond_to do |format|\n format.html { redirect_to mfiles_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @music = Music.find_by_sql(\"SELECT * FROM Musics M Where M.id = \" + params[:id]).first()\n @music.destroy\n\n respond_to do |format|\n format.html { redirect_to \"/musics\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @microfilm_reel = MicrofilmReel.find(params[:id])\n @microfilm_reel.destroy\n\n respond_to do |format|\n format.html { redirect_to microfilm_reels_url }\n format.json { head :no_content }\n end\n end"
] |
[
"0.8106292",
"0.7840484",
"0.75499827",
"0.7509205",
"0.744935",
"0.74101496",
"0.73800826",
"0.73797673",
"0.7367843",
"0.73671913",
"0.735851",
"0.73511904",
"0.73482156",
"0.7339288",
"0.73315656",
"0.73087883",
"0.7264992",
"0.7242742",
"0.7216486",
"0.721182",
"0.7200243",
"0.71767294",
"0.7135662",
"0.7129136",
"0.71101356",
"0.7110042",
"0.70991594",
"0.709807",
"0.70892924",
"0.7073444",
"0.7073444",
"0.7073444",
"0.70706975",
"0.7063461",
"0.706157",
"0.70573914",
"0.70229495",
"0.70127183",
"0.6992533",
"0.6991879",
"0.69878393",
"0.69661796",
"0.6937089",
"0.69369656",
"0.69266593",
"0.6907909",
"0.68997025",
"0.6899172",
"0.68746793",
"0.6871132",
"0.6863836",
"0.68545127",
"0.6846114",
"0.68439245",
"0.68420255",
"0.6831287",
"0.6829149",
"0.68200517",
"0.68105376",
"0.6800613",
"0.67939216",
"0.679029",
"0.6788468",
"0.6779804",
"0.6774018",
"0.67664415",
"0.6764866",
"0.6764183",
"0.67559195",
"0.675175",
"0.6751598",
"0.67500126",
"0.6744613",
"0.67419845",
"0.67407197",
"0.67399675",
"0.6734764",
"0.6734608",
"0.67345744",
"0.6733873",
"0.6728461",
"0.6725796",
"0.67248476",
"0.6719847",
"0.6718062",
"0.67112184",
"0.6710135",
"0.67095685",
"0.67084897",
"0.670403",
"0.67028016",
"0.67022705",
"0.67006624",
"0.6698951",
"0.6698416",
"0.66979235",
"0.6697409",
"0.66959864",
"0.6690598",
"0.6685512"
] |
0.7487068
|
4
|
Use callbacks to share common setup or constraints between actions.
|
def set_extend_demography
@extend_demography = ExtendDemography.find(params[:extend_demography_id])
@url_back = url_back
rescue ActiveRecord::RecordNotFound
render_404
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
|
before_action :authenticate_user, only: [:index, :show]
|
def index
@tags = Tag.all
@prices = Price.all
@favorite = Favorite.all
@bars = Bar.last(9)
@cities = Bar.pluck(:city)
@bars_search_by_my_user = Bar.new
@gigs = Gig.last(4)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def index\n redirect_to current_user\n end",
"def show\n skip_authorization\n end",
"def show\n # authorize Admin\n end",
"def index\n redirect_to(:action => 'login') and return unless logged_in?\n \n @user = current_user\n end",
"def index\n redirect_to @current_user if current_user\n end",
"def index\n redirect_to after_sign_in_path_for current_user if current_user\n end",
"def index\n redirect_to after_sign_in_path_for current_user if current_user\n end",
"def index\n head :unauthorized\n end",
"def show\n authorize User\n end",
"def show\n authorize User\n end",
"def index\n redirect_to(:action => 'login') unless logged_in? \n end",
"def show\n redirect_to login_path \n end",
"def index\n if is_logged_in\n redirect_to(:action=>'list')\n end\n #all logic in login_redirect_logic\n end",
"def show\n authorize! :show, @user\n end",
"def index\r\n redirect_to :action => :login\r\n end",
"def authenticate_user\n\t\trender_unauthorized unless current_user\n\tend",
"def index\n User.all #take all auth stuff\n end",
"def index\n # set_user, is the only action taken here\n end",
"def index\n # set_user, is the only action taken here\n end",
"def index\n redirect_to(:action => 'login') #unless logged_in? || User.count > 0\n end",
"def index\n # Handle bookmarked or otherwise incorrect GETs to the login action\n if request.method == :get\n redirect_to login_path\n else\n redirect_to member_home_path\n end\n end",
"def show\n authorize!\n end",
"def show\n authorize!\n end",
"def show\n authorize!\n end",
"def authenticate\n \treturn if controller_name == \"pages\"\n \tif !logged_in?\n \t\tflash[:alert] = \"Must be an admin or a nutritionist\"\n \t\tredirect_to root_path\n \tend\n end",
"def authorized\n redirect_to :controller => 'home', :action => 'index' unless logged_in?\n end",
"def index\n # if !user_signed_in?\n # redirect_to new_user_session_path\n # end\n end",
"def index\n @user = current_user\n end",
"def index\n if signed_in?\n redirect_to current_user\n else\n redirect_to new_user_path\n end\n end",
"def show\n if current_user.access == 2\n redirect_to \"/users/indexU\"\n end\n end",
"def index\n @users = User.all\n authorize User\n end",
"def authenticate_user!\n \tunless current_user?\n \trender status: :unauthorized\n \tend\n end",
"def show\n redirect_user\n end",
"def index\n #before_action :authenticate_user\n #if current_user.admin?\n @users = User.all\n render json: @users, status: :ok\n #else\n # render json: [], status: :unauthorized\n #end\n end",
"def show\n authorize @user\n end",
"def show\n authorize @user\n end",
"def index\n # Handle bookmarked or otherwise incorrect GETs to the login action\n if request.method == :get\n redirect_to login_path\n else\n redirect_to vault_dashboard_path\n end\n end",
"def show\n \tauthorize! :read, @user\n end",
"def show\n authorize Session\n end",
"def authenticate\n\n redirect_to_login if current_user.nil?\n \n end",
"def authenticate\n redirect_to :login unless user_signed_in?\n end",
"def index\n # Shut up I know this is stupid\n @users = User.all\n unless user_signed_in? and current_user.is_admin?\n redirect_to root_path, notice: \"Log in first\"\n end\n end",
"def authorized_user!\n unless user_logged_in?\n redirect_to root_path\n end\n end",
"def index\n @current_user = current_user if signed_in?\n end",
"def show\n if user_signed_in?\n else\n redirect_to root_path\n end\n end",
"def must_be_authenticated!\n unless current_admin\n redirect_to :controller => 'home', :action => 'index'\n end\n end",
"def show\n login\n render view_for_user\n end",
"def show\n @user = current_user\n authorize @user\n end",
"def index\n\n\n # if ( !current_user || !current_user.isAdmin )\n # render :text => \"You are not authorized to see this page\", :layout => true\n #\n # return\n # end\n\n @users = User.all\n end",
"def show\n redirect_to users_index_url\n end",
"def authenticate\n unauthorized unless current_user\n end",
"def needs_authenticate_user?\n except_actions = %w[index show]\n !except_actions.include?(action_name)\n end",
"def index\n\n #Make sure only logged in admins can manipulate users\n\n if @loggedinuser && @loggedinuser.authorizationlevel >= 4\n else \n redirect_to '/'\n end\n end",
"def authenticate\n redirect_to login_path if !logged_in\n end",
"def index\n if current_user.admin? or current_user.editor? #checks if user is admin, if so displays all of the students in database.\n @students = Student.all\n if params[:search]\n @students = Student.search(params[:search]).order(\"created_at DESC\")\n else\n @students = Student.all.order('created_at DESC')\n end\n elsif user_signed_in?\n @students = Student.all.where(:user_id => current_user.id) #Only displays the the users student. \n end\n\n\n authorize @students\n end",
"def index\n @users = User.all\n authorize @users\n end",
"def show\n authorize Section\n end",
"def redirect_to_index\n redirect_to :action => 'index' unless current_user\n @user = current_user\n end",
"def index\n redirect_to user_path(current_user)\n end",
"def index \n @patients = current_user.patients \n # Which patients should a user see when they're logged in? \n # We only show the patients that belong to the current user.\n # With devise, current_user is accessible in controllers and views. \n # If there is no current user or a User isn't logged in we're redirected to login ?? \n end",
"def authenticate\n redirect_to '/login' unless current_user\n end",
"def show\n if current_user.nil?\n redirect_to '/'\n end\n end",
"def authorize\n redirect_to :root, alert: 'You must be logged in to view this page' if current_user.nil?\n end",
"def authenticate!\n unless current_user\n redirect \"/login\"\n end\nend",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def index\n redirect_to :nieuw if current_user\n end",
"def authorized\n redirect_to \"/login\" unless logged_in? \n end",
"def authenticate!\n\t\t\tunless signed_in? or params[:controller].include?\"devise\"\n\t\t\t\tflash[:notice] = \"You're not logged in!\"\n\t\t\t\tredirect_to :root\n\t\t\tend\n\t\tend",
"def index\n\t\tredirect_to dashboard_users_path if current_user\n\tend",
"def index\n if user_signed_in?\n redirect_to home_path\n end\n end",
"def index\n if user_signed_in?\n redirect_to home_path\n end\n end",
"def authenticate\n deny_access unless signed_in? \n end",
"def show\n self.current_user\n \n if not @current_user\n redirect_to login_path\n else\n render :action => 'edit'\n end\n end",
"def authenticate_user\n redirect_to \"/login\" unless logged_in?\n end",
"def authenticate_current_user\n unless current_user.admin == true\n unless current_user == User.find(params[:id]) \n flash[:danger] = \"Impossible d'aller sur cette page.\"\n redirect_to root_path\n end\n end\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def show\n require_user()\n end",
"def authenticate_user!\n unless current_user?\n render status: :unauthorized\n end\n end",
"def authenticate!\r\n\tif !current_user\r\n\t\tredirect \"/login\"\r\n\tend\r\nend",
"def show\n enforce_view_permission(@user)\n \n end",
"def show\n if not ( paziente_signed_in? or administrator_signed_in?)\n redirect_to root_path and return\n end\n end",
"def authenticate\n\t\tdeny_access unless signed_in?\n\tend",
"def authorized\n if logged_in?\n return View(\"sessions/page_requires_login\"); \n end\n return View(\"Index\")\n end",
"def authenticate\n unless logged_in?\n redirect_to login_url\n end\n end",
"def authorize\n redirect_to '/login' unless current_user\n end",
"def show\n render layout: 'devise_layout' if current_user.present? && current_user.admin?\n end",
"def user_authentication\n end",
"def index\n if not current_user.role? :admin\n redirect_to root_path\n end\n end",
"def show\n authorize! :create, Administrator\n end",
"def authorize\n redirect_to :login unless user_signed_in?\n end",
"def show\n redirect_to(default_url) unless logged_in? || User.count > 0\n @user = current_user\n end",
"def show\n redirect_to root_path, alert: \"You are not authorised to view that page.\"\n end",
"def show\n # Pundit authorization can be skipped because\n # before_filter :authorize_user_index handles authorization\n skip_authorization\n\n @user = User.find_by_id(params[:id])\n\n if @user == nil\n @user = User.find_by_id(current_user.id)\n end\n\n respond_to do |format|\n format.html\n format.json { render :json => @user, status: 200 }\n end\n end",
"def listing\n @user = User.all\n unless current_user.admin?\n redirect_to dashboard_show_path\n end \n end"
] |
[
"0.75556827",
"0.745496",
"0.7448857",
"0.7411959",
"0.7402401",
"0.7381169",
"0.7381169",
"0.7304431",
"0.7266621",
"0.7266621",
"0.72559065",
"0.72340584",
"0.7223579",
"0.7192612",
"0.71893847",
"0.7179142",
"0.71746325",
"0.7158757",
"0.7158757",
"0.7157501",
"0.7148973",
"0.71474797",
"0.71474797",
"0.71474797",
"0.7138856",
"0.7136676",
"0.7129031",
"0.7117747",
"0.70991135",
"0.7070614",
"0.70504665",
"0.7035676",
"0.7033428",
"0.7026529",
"0.7025049",
"0.7025049",
"0.7015484",
"0.7011341",
"0.6989247",
"0.6981732",
"0.69736993",
"0.6966132",
"0.6940932",
"0.6939955",
"0.6939588",
"0.6930051",
"0.6928934",
"0.69233805",
"0.69223523",
"0.6913428",
"0.690333",
"0.6901119",
"0.6897113",
"0.6894672",
"0.68919253",
"0.68815345",
"0.6881282",
"0.68794566",
"0.68771034",
"0.6876001",
"0.6864502",
"0.6857991",
"0.6849099",
"0.68455464",
"0.6843395",
"0.6839434",
"0.68348175",
"0.68343735",
"0.68324834",
"0.6824679",
"0.6824679",
"0.6821757",
"0.6819463",
"0.6815387",
"0.68118817",
"0.6809335",
"0.6809335",
"0.6809335",
"0.6809335",
"0.6809335",
"0.6809335",
"0.6809335",
"0.6809335",
"0.6806151",
"0.6800447",
"0.6798408",
"0.67982066",
"0.67946815",
"0.6793042",
"0.6791958",
"0.6788591",
"0.67883545",
"0.67871493",
"0.6772139",
"0.6765038",
"0.67596936",
"0.6759329",
"0.67553174",
"0.6754987",
"0.6754465",
"0.67508584"
] |
0.0
|
-1
|
Called after the WebSocket handshake completes.
|
def connected(query)
join_key = query['key']
if join_key
@nexus.user_by_key join_key do |user|
if user && !user.session
@user = user
@room = user.room
@user.set_session self
respond hi: 'ok'
else
@ws.close_websocket
end
end
else
@ws.close_websocket
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def ssl_handshake_completed\n connected!\n end",
"def post_init\n @state = :connecting\n @handshake = ::WebSocket::Handshake::Server.new(:secure => @secure_proxy)\n start_tls(@tls_options) if @secure\n end",
"def ssl_handshake_completed\n auth_data = {\n api_key: client.api_key,\n instance: client.instance_name,\n 'user-agent' => \"syncano-ruby-#{Syncano::VERSION}\"\n }\n\n auth_data[:auth_key] = client.auth_key if client.auth_key.present?\n\n client.connection = self\n\n send_data \"#{auth_data.to_json}\\n\"\n end",
"def handle_websocket_handshake( handshake )\n\t\tself.log.warn \"Unhandled WEBSOCKET_HANDSHAKE request (%p)\" % [ handshake.headers.path ]\n\t\tself.conn.reply_close( handshake )\n\n\t\treturn nil\n\tend",
"def complete_handshake\n if @state == :handshake\n log.debug { 'Handshake completed' }\n @state = :connected\n @started = Time.now\n @node.push_notification(:connection, info.merge(type: :connected))\n @node.addrs << addr\n end\n send_data P::Addr.pkt(@node.addr) if @node.config[:announce]\n end",
"def connection_completed\n @connection_completed = true\n begin_handshake\n rescue Exception\n log.fatal { \"Error in #connection_completed\" }\n p $!; puts *$@\n end",
"def close_websocket\n if @handler\n @handler.close_websocket\n else\n # The handshake hasn't completed - should be safe to terminate\n close_connection\n end\n end",
"def handshake\n end",
"def _post_connect()\n return unless (@connect_headers[:\"accept-version\"] && @connect_headers[:host]) # 1.0\n if @connection_frame.command == Stomp::CMD_ERROR\n @connection_frame.headers = _decodeHeaders(@connection_frame.headers)\n return\n end\n # We are CONNECTed\n cfh = @connection_frame.headers.symbolize_keys\n @protocol = cfh[:version]\n if @protocol\n # Should not happen, but check anyway\n raise Stomp::Error::UnsupportedProtocolError unless Stomp::SUPPORTED.index(@protocol)\n else # CONNECTed to a 1.0 server that does not return *any* 1.1 type headers\n @protocol = Stomp::SPL_10 # reset\n return\n end\n # Heartbeats\n return unless @connect_headers[:\"heart-beat\"]\n _init_heartbeats()\n end",
"def on_close(env)\n @subscription.delete if @subscription\n logger.debug \"WebSocket closing connection\"\n end",
"def connection_completed\n JR::JobLogger.log('Begin distributor handshake')\n data = {node_info: {name: @node.config[:name], server: @node.server} }\n data = Marshal.dump(data)\n send_data(data)\n end",
"def connection_completed\n end",
"def tls_successful_handshake\n logdebug \"Succesful handshake!\"\n end",
"def connection_completed\n start_tls\n end",
"def connection_completed\n start_tls\n end",
"def on_close\n websocket_client.on(:close) do |event|\n p [:close, event.code, event.reason]\n end\n end",
"def connection_completed\n @connection_state = :connected\n @connection_state_callback.call if @connection_state_callback\n end",
"def connection_completed\n @connected = true\n send_request @args\n end",
"def on_message_complete\n send_response\n close_socket\n write_to_screen\n end",
"def connection_completed\n @connected = true\n Skates.logger.debug {\n \"CONNECTED\"\n } # Very low level Logging\n end",
"def ssl_handshake_completed\n log_system_debug(\"TLS connection established to \" << remote_desc) if $oversip_debug\n\n # @connected in TlsClient means \"TLS connection\" rather than\n # just \"TCP connection\".\n @connected = true\n @timer_tls_handshake.cancel if @timer_tls_handshake\n\n # Run OverSIP::SipEvents.on_server_tls_handshake.\n ::Fiber.new do\n if @callback_on_server_tls_handshake\n log_system_debug \"running OverSIP::SipEvents.on_server_tls_handshake()...\" if $oversip_debug\n begin\n ::OverSIP::SipEvents.on_server_tls_handshake self, @server_pems\n rescue ::Exception => e\n log_system_error \"error calling OverSIP::SipEvents.on_server_tls_handshake():\"\n log_system_error e\n close_connection\n end\n\n # If the user or peer has closed the connection in the on_server_tls_handshake() callback\n # then notify pending transactions.\n if @local_closed or error?\n log_system_debug \"connection closed, aborting\" if $oversip_debug\n @pending_client_transactions.each do |client_transaction|\n client_transaction.tls_validation_failed\n end\n @pending_client_transactions.clear\n @pending_messages.clear\n @state = :ignore\n end\n end\n\n @pending_client_transactions.clear\n @pending_messages.each do |msg|\n send_data msg\n end\n @pending_messages.clear\n end.resume\n end",
"def socket_connected\n post_init\n end",
"def ssl_handshake_completed\n begin\n return unless @@options[:verify_ssl]\n close_connection unless Http::SSLValidator.validate(@certs, @host)\n rescue Exception => e\n @@logger.error(\"Error in ssl_handshake_completed: #{e}\")\n raise e\n end\n end",
"def connection_status_done; end",
"def connection_completed\n connect @conn_headers # call EM supplied CONNECT method\n @log.debug(\"#{self} connection_completed done\")\n end",
"def connection_completed\n # We aren't completely connected yet if the connection is encrypted.\n connected! unless @network.secure?\n end",
"def on_handshake_begin\n @state = :handshake\n from = \"#{@node.external_ip}:#{@node.config[:listen][1]}\"\n version = Bitcoin::Protocol::Version.new({\n :version => 70001,\n :last_block => @node.store.get_depth,\n :from => from,\n :to => @host,\n :user_agent => \"/bitcoin-ruby:#{Bitcoin::VERSION}/\",\n #:user_agent => \"/Satoshi:0.8.1/\",\n })\n send_data(version.to_pkt)\n log.debug { \"<< version (#{Bitcoin.network[:protocol_version]})\" }\n end",
"def connection_completed\n# @keepalive = EM::PeriodicTimer.new(60) { send_data ' ' }\n start\n end",
"def receive(websocket_message); end",
"def finish\n begin\n @socket.close\n rescue\n end\n on_disconnected\n end",
"def connection_completed\n if REQUEST_PROTOCOL == 'https'\n start_tls\n end\n\n #Resets connection state\n flush_connection_state\n\n #Constructing request hash\n request_options = {}\n request_options[:request_method] = REQUEST_METHOD\n request_options[:request_protocol] = REQUEST_PROTOCOL\n request_options[:host] = HOST\n request_options[:url_path] = @options[:path]\n request_options[:query_params] = @options[:query_params]\n request_options[:request_body] = @options[:request_body]\n request_options[:oauth] = @options[:oauth]\n\n request = TwitterStreaming::HTTPRequest.new(request_options)\n\n request_string = request.to_string\n\n #Sending raw request data over socket\n send_data request_string\n end",
"def connection_status_handshake; end",
"def connection_ended\n end",
"def connection_ended\n end",
"def connection_completed\n\tend",
"def ssl_handshake_completed\n return unless @tls_options[:verify_peer]\n @client_cert = get_peer_cert\n close_connection if @client_cert && !valid_client?(@client_cert)\n end",
"def send_handshake_response(socket, ws_accept)\n\tsocket << \"HTTP/1.1 101 Switching Protocols\\r\\n\" +\n\t\"Upgrade: websocket\\r\\n\" +\n\t\"Connection: Upgrade\\r\\n\" +\n\t\"Sec-WebSocket-Accept: #{ws_accept}\\r\\n\"\n end",
"def connection_completed()\n super()\n puts \"#{self} connection_completed done!\"\n end",
"def connection_completed()\n super()\n puts \"#{self} connection_completed done!\"\n end",
"def connection_completed()\n super()\n puts \"#{self} connection_completed done!\"\n end",
"def on_session_ended\n @connection = nil\n\n # Automatically reconnect to the server if allowed\n if @reconnect\n reconnect_from(Exception) do\n connect\n trigger(:reconnected)\n end\n end\n end",
"def state_done\n close_connection_after_writing\n end",
"def on_handshake_succeeded( fd, endpoint )\n\t\t\tself.log.debug \"Client socket on FD %d handshake succeeded\" % [ fd ]\n\t\tend",
"def websocket; end",
"def websocket; end",
"def connection_completed\n log_debug '[client-cnxn] Established server connection, sending request'\n send_request unless error?\n rescue\n fail(:RPC_ERROR, 'Connection error: %s' % $!.message) unless failed?\n end",
"def connection_successful\n @authenticating = false\n opened!\n\n exec_callback_yielding_self(:connect)\n end",
"def post_init\n @connected = true\n end",
"def post_init\n @connected = true\n end",
"def on_close(env)\n subscription.unsubscribe\n Firehose.logger.debug \"WS connection `#{cid}@#{path}` closing\"\n end",
"def post_init\n if incoming?\n begin_handshake\n end\n rescue Exception\n log.fatal { \"Error in #post_init\" }\n p $!; puts *$@\n end",
"def handle_websocket( request )\n\t\tself.log.warn \"Unhandled WEBSOCKET frame (%p)\" % [ request.headers.path ]\n\t\tres = request.response\n\t\tres.make_close_frame( Mongrel2::WebSocket::CLOSE_POLICY_VIOLATION )\n\n\t\tself.conn.reply( res )\n\t\tself.conn.reply_close( request )\n\n\t\treturn nil\n\tend",
"def handle_close(request, event)\n SockJS.debug \"WebSocket#handle_close\"\n # SockJS.debug \"Closing WS connection.\"\n #\n # # If it's the user app who closed\n # # the response, we won't ever get\n # # to pass this point as we'll get\n # # SessionUnavailableError.\n # self.get_session(request.path_info)\n # rescue SockJS::SessionUnavailableError => error\n # # TODO: Set status is necessary(?)\n # # error.session\n end",
"def notify_ready\n # Make sure to raise the event\n raise_event(ReadyEvent.new(self))\n LOGGER.good 'Ready'\n\n # Tell the run method that everything was successful\n @ws_success = true\n end",
"def hand_finished\n\t\t\t\tloop do\n\t\t\t\t\tline = socket_get\n\t\t\t\t\tinterpret_acpc_matchstate(line) # update cards and things\n\t\t\t\t\tif line == '#END_HAND'\n\t\t\t\t\t\t# now the hand has really finished\n\t\t\t\t\t\tsuper\n\t\t\t\t\t\tbreak\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\tend",
"def on_connected\n end",
"def after_stream\n end",
"def on_verack\n log.debug { \">> verack\" }\n complete_handshake if outgoing?\n end",
"def connection_completed\n\t\tsend_data \"#{$username}:#{$password}\"\n\tend",
"def post_init\n self.dispatch_event(:on_connect, [self])\n self.send_data(SyncMessage.new($listen_port, $uuid).to_sendable)\n end",
"def on_connection_success &block\n @connection_success_callback = block\n end",
"def post_init\n connection.logger.info \"Connected to Voldemort node at #{connection.host}:#{connection.port}\"\n send_protocol_proposal(connection.protocol)\n in_flight.errback do |response|\n connection.logger.warn \"Voldemort protocol #{connection.protocol} not accepted: #{response.inspect}\"\n end\n end",
"def on_connection_close &block\n @connection_close_callback = block\n end",
"def post_init\n send_message(MosesPG::Message::StartupMessage.new(@user, @dbname))\n\n # when we enter the ready state after connecting, send self to the\n # callback\n @result = FakeResult.new(self)\n self\n end",
"def connection_completed\n ## start sending KEEP_ALIVE_MESSAGE\n puts 'sending keep_alive sending ...'\n EM::PeriodicTimer.new(KEEP_ALIVE_INTERVAL) { send_data KEEP_ALIVE_MESSAGE }\n end",
"def disconnection_successful\n exec_callback_yielding_self(:disconnect)\n close_connection\n closed!\n end",
"def on_message_complete\n @finished = true\n end",
"def handle_hello(payload)\n LOGGER.info { 'Connected' }\n @heartbeat_interval = payload[:d][:heartbeat_interval] / 1000\n @heartbeat_thread = Thread.new { heartbeat_loop }\n if @session.seq\n send_resume\n else\n send_identify\n end\n end",
"def close_connection\n @connection.finish\n end",
"def post_connect_hooks; end",
"def post_connect_hooks; end",
"def server_connection_success\n LOGGER.info \"Successful connection to #{@remote.join(':')}\"\n @connected = true\n @server_side.send_data(@buffer_out)\n @buffer_out = ''\n end",
"def after_connect\n redis_connect\n set_adapters\n set_callbacks\n end",
"def on_shutdown\n\t\tend",
"def finalize(connection)\n selector = CLIENT_CONTINUE_MESSAGE.merge(\n payload: client_empty_message,\n conversationId: id,\n )\n build_message(connection, user.auth_source, selector)\n end",
"def begin_handshake\n if incoming? && !@node.accept_connections?\n return close_connection unless @node.config[:connect].include?([@host, @port.to_s])\n end\n log.info { \"Established #{@direction} connection\" }\n @node.connections << self\n @state = :handshake\n send_version\n rescue Exception\n log.fatal { \"Error in #begin_handshake\" }\n p $!; puts *$@\n end",
"def connection_successful\n @connection_deferrable.succeed\n end",
"def connect\n succeed # Triggers all callbacks for class\n end",
"def on_initialization_finished()\n end",
"def run\n websocket.run\n end",
"def disconnect\n littlewire.finished\n super\n end",
"def finalize()\n @ssl_client.close\n end",
"def client_connected\n end",
"def after_script\n websockify_cmd = context.fetch(:websockify_cmd, \"${WEBSOCKIFY_CMD:-/opt/websockify/run}\").to_s\n\n <<-EOT.gsub(/^ {14}/, \"\")\n #{super}\n\n # Launch websockify websocket server\n echo \"Starting websocket server...\"\n websocket=$(find_port)\n [ $? -eq 0 ] || clean_up 1 # give up if port not found\n #{websockify_cmd} -D ${websocket} localhost:${port}\n\n # Set up background process that scans the log file for successful\n # connections by users, and change the password after every\n # connection\n echo \"Scanning VNC log file for user authentications...\"\n while read -r line; do\n if [[ ${line} =~ \"Full-control authentication enabled for\" ]]; then\n change_passwd\n create_yml\n fi\n done < <(tail -f --pid=${SCRIPT_PID} \"#{vnc_log}\") &\n EOT\n end",
"def sync\n @ws_thread.join\n end",
"def sync\n @ws_thread.join\n end",
"def call(env)\n # trace __FILE__, __LINE__, self, __method__, \"env=#{env}\"\n protocols = nil\n options = { ping: 5 } # keep socket alive : Chrome seems to time out in about 10?\n socket = Faye::WebSocket.new(env, protocols, options)\n connect!(socket)\n # trace __FILE__, __LINE__, self, __method__\n socket.rack_response\n end",
"def initialize(url, cookies, logs: false, &handler)\n @super_logger = Logger.new(logs ? 'ws_super_logger.log' : '/dev/null')\n\n @uri = URI.parse(url)\n @url = \"ws#{@uri.scheme.split(\"\")[4]}://#{@uri.host}\"\n\n if @uri.scheme.split(\"\")[4] == 's'\n @socket = TCPSocket.new(@uri.host, 443)\n @super_logger.info \"Opened TCP socket for (port 443) #{@uri} (#{@socket})\"\n @socket = OpenSSL::SSL::SSLSocket.new(@socket)\n @socket.connect\n @super_logger.info \"Upgrade TCP socket to SSL socket socket for #{@uri} (#{@socket})\"\n else\n @socket = TCPSocket.new(@uri.host, 80)\n @super_logger.info \"Opened TCP socket for (port 80) #{@uri} (#{@socket})\"\n end\n\n @handler = handler\n @logger = Logger.new(logs ? \"realtime.log\" : '/dev/null')\n @restart = true\n @super_logger.info \"Set @restart to #{@restart}\"\n\n @driver = WebSocket::Driver.client(self)\n @driver.add_extension PermessageDeflate\n @driver.set_header \"Cookies\", cookies if cookies\n @driver.set_header \"Origin\", \"#{@uri.scheme}://#{@uri.host.split('.')[-2..-1].join('.')}\"\n\n @driver.on :connect, ->(_e) {}\n\n @driver.on :open, ->(_e) do\n send \"155-questions-active\"\n @super_logger.info \"Socket open. Subscribed to 155-questions-active\"\n @logger.info \"WebSocket is open!\"\n end\n\n @driver.on :message do |e|\n @logger.info(\"Read: #{e.data}\")\n data = JSON.parse(e.data)\n if data[\"action\"] == \"hb\"\n send \"hb\"\n else\n @handler.call(data)\n end\n end\n\n @driver.on :close, ->(_e) do\n @logger.info \"Realtime WebSocket is closing.\"\n @super_logger.info \"Socket was closed. @restart == #{@restart}\"\n if @restart\n @logger.info \"Attempting to reopen websocket...\"\n @super_logger.info \"Attempting to reopen socket\"\n @driver.start\n end\n end\n\n @driver.on :error, ->(e) { @logger.error e }\n\n @driver.start\n\n @dead = false\n @thread = Thread.new do\n trap(\"SIGINT\") do\n @restart = false\n @dead = true\n @super_logger.info \"Got SIGINT. Dying.\"\n close\n Thread.exit\n end\n begin\n @driver.parse(@socket.is_a?(TCPSocket) ? @socket.recv(1) : @socket.sysread(1)) until @dead\n rescue IOError, SystemCallError => e\n @super_logger.warn \"Got some kind of interrupt in the thread. Panic.\"\n @logger.warn \"Recieved #{e} closing TCP socket. You shouldn't be worried :)\"\n end\n @super_logger.warn \"Left TCPSocket.recv loop. If you're reading this, panic.\"\n end\n\n at_exit { @thread.join }\n end",
"def done\n @closed = true\n send_headers\n ::EM.next_tick { @body.succeed }\n end",
"def after_hash_token_authentication\n end",
"def on_connection_established(&block)\n @on_connection_established_block = block\n end",
"def post_init\n # setup single-shot version of receive_marshalled_message\n class <<self\n alias_method :receive_marshalled_message, :receive_handshake_message\n end\n end",
"def end\n # todo: catch when there is no valid session?\n do_request(:post, path: @config[:end_session_url], payload: {:SessionToken => @session_token})\n connection.headers['x-sessionToken'] = ''\n @session_token = ''\n end",
"def on_connecting\n\t\t\t\t@@connected = false\n\t\t\t\tpublish('zk_connecting')\n\t\t\tend",
"def handshake(message, local = false, &callback)\n response = make_response(message)\n response['version'] = BAYEUX_VERSION\n\n response['error'] = Error.parameter_missing('version') if message['version'].nil?\n\n client_conns = message['supportedConnectionTypes']\n\n response['supportedConnectionTypes'] = CONNECTION_TYPES\n\n if client_conns\n common_conns = client_conns.select { |c| CONNECTION_TYPES.include?(c) }\n response['error'] = Error.conntype_mismatch(*client_conns) if common_conns.empty?\n else\n response['error'] = Error.parameter_missing('supportedConnectionTypes')\n end\n\n response['successful'] = response['error'].nil?\n return callback.call(response) unless response['successful']\n\n @engine.create_client do |client_id|\n response['clientId'] = client_id\n callback.call(response)\n end\n end",
"def on_close(event)\n logger.debug 'Socket closed'\n @connected = false\n @socket = nil\n dispatch('command' => 'session_ended')\n end",
"def on_close(event)\n logger.debug 'Socket closed'\n @connected = false\n @socket = nil\n dispatch('command' => 'session_ended')\n end",
"def finalize_session\n @savon.call :finalize_session, \n message: { 'wsdl:sessionID' => @session_id }\n end",
"def connect(url, options={})\n puts \"start ***************\"\n return if @socket\n @url = url\n uri = URI.parse url\n @socket = TCPSocket.new(uri.host,\n uri.port || (uri.scheme == 'wss' ? 443 : 80))\n if ['https', 'wss'].include? uri.scheme\n ctx = OpenSSL::SSL::SSLContext.new\n ctx.ssl_version = options[:ssl_version] || 'SSLv23'\n ctx.verify_mode = options[:verify_mode] || OpenSSL::SSL::VERIFY_NONE #use VERIFY_PEER for verification\n cert_store = OpenSSL::X509::Store.new\n cert_store.set_default_paths\n ctx.cert_store = cert_store\n @socket = ::OpenSSL::SSL::SSLSocket.new(@socket, ctx)\n @socket.connect\n end\n puts url\n @handshake = ::WebSocket::Handshake::Client.new :url => url, :headers => options[:headers]\n puts @handshake.to_s\n @handshaked = false\n @pipe_broken = false\n frame = ::WebSocket::Frame::Incoming::Client.new\n @closed = false\n once :__close do |err|\n puts \"clooooseeee ***********\"\n close\n emit :close, err\n end\n puts frame\n @thread = Thread.new do\n puts \"start while!!!!***********\"\n while !@closed do\n begin\n # puts \"1 ***************\"\n unless recv_data = @socket.getc\n puts \"2 ***************\"\n sleep 1\n next\n end\n unless @handshaked\n # puts \"3 ***************\"\n @handshake << recv_data\n if @handshake.finished?\n @handshaked = true\n puts \"Open!!!\"\n emit :open\n end\n else\n puts \"4 ***************\"\n frame << recv_data\n while msg = frame.next\n puts \"msg ***************\"\n emit :message, msg\n end\n end\n rescue => e\n puts \"error ***************\"\n emit :error, e\n end\n end\n end\n puts \"write ***************\"\n @socket.write @handshake.to_s\n end",
"def finalize\n puts \"finalize\"\n @terminated = true\n @tuple_space_server_receiver.terminate\n @socket.close\n @updater.terminate\n @tuple_space_servers = []\n end",
"def connect\n self.send({\n msg: :connect,\n version: @version,\n support: @support\n })\n\n #handle incoming response form the server\n self.onmessage = lambda do |event|\n\n res = JSON.parse(event.data)\n\n if res.has_key? 'session'\n #connection is successful - update session and record version\n @session = res['session'].to_s\n @@last_suc_version = @version\n\n else #there was a failed connection\n @version = res['version']\n #retry the send request with the version specified by the server\n self.send({\n msg: :connect\n version: @version,\n support: @support\n })\n end\n\n end\n end"
] |
[
"0.7383703",
"0.68649566",
"0.6817576",
"0.6753346",
"0.6732809",
"0.65693104",
"0.65659815",
"0.6560655",
"0.6473209",
"0.646189",
"0.6434203",
"0.64334786",
"0.6341668",
"0.63372535",
"0.63372535",
"0.6307783",
"0.6306671",
"0.6291704",
"0.6239273",
"0.61899674",
"0.6179674",
"0.6174929",
"0.61482763",
"0.61255085",
"0.61213255",
"0.6087634",
"0.6073182",
"0.6068893",
"0.6058906",
"0.6044926",
"0.60255206",
"0.5989213",
"0.5974952",
"0.5974952",
"0.5958925",
"0.5952385",
"0.59195954",
"0.591548",
"0.591548",
"0.591548",
"0.5897607",
"0.58832276",
"0.58597946",
"0.58591604",
"0.58591604",
"0.58224535",
"0.581599",
"0.57800144",
"0.57800144",
"0.576681",
"0.57545155",
"0.5746565",
"0.5727532",
"0.56950194",
"0.5681643",
"0.56719565",
"0.56678003",
"0.5664181",
"0.56509507",
"0.5643301",
"0.56194913",
"0.5616551",
"0.56137156",
"0.5581713",
"0.55815274",
"0.5580222",
"0.5579519",
"0.5516178",
"0.5504205",
"0.54824287",
"0.54824287",
"0.54741",
"0.5450365",
"0.5413747",
"0.5408075",
"0.540649",
"0.5404531",
"0.54042596",
"0.54041666",
"0.53947407",
"0.53939265",
"0.53906184",
"0.5382727",
"0.53582835",
"0.53581226",
"0.53581226",
"0.53504664",
"0.53484714",
"0.53448766",
"0.53407013",
"0.5334442",
"0.5328221",
"0.5321332",
"0.53188425",
"0.5318407",
"0.5317962",
"0.5317962",
"0.5307159",
"0.5297605",
"0.5295953",
"0.5290164"
] |
0.0
|
-1
|
Called when the client closes the WebSocket.
|
def closed
if @user && @room
@user.remove_session
@room = nil
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def on_close\n websocket_client.on(:close) do |event|\n p [:close, event.code, event.reason]\n end\n end",
"def on_close(env)\n @subscription.delete if @subscription\n logger.debug \"WebSocket closing connection\"\n end",
"def websocket_connection_close(ws, client)\n ws.on :close do |event|\n Services::Clients.collection.delete(client)\n ws = nil\n end\n end",
"def close(event)\n if event && !event.target.kind_of?(Faye::WebSocket::Client) then\n logger.debug { \"closed connection from #{event.target.env[\"REMOTE_ADDR\"]} (code=#{event.code}; reason=\\\"#{event.reason}\\\")\" }\n end\n if @connected then\n @connected = false\n @handler.new(nil).disconnect(self)\n end\n end",
"def handle_close(request, event)\n SockJS.debug \"WebSocket#handle_close\"\n # SockJS.debug \"Closing WS connection.\"\n #\n # # If it's the user app who closed\n # # the response, we won't ever get\n # # to pass this point as we'll get\n # # SessionUnavailableError.\n # self.get_session(request.path_info)\n # rescue SockJS::SessionUnavailableError => error\n # # TODO: Set status is necessary(?)\n # # error.session\n end",
"def close_websocket\n if @handler\n @handler.close_websocket\n else\n # The handshake hasn't completed - should be safe to terminate\n close_connection\n end\n end",
"def on_close(env)\n subscription.unsubscribe\n Firehose.logger.debug \"WS connection `#{cid}@#{path}` closing\"\n end",
"def on_close client\n controller(client).on_close\n end",
"def on_close(ws)\n client = @clients.find{|c| c[:ws] == ws}\n if client\n logger.info \"node #{client[:id]} connection closed\"\n unplug_client(client)\n else\n logger.debug \"ignore close of unplugged client\"\n end\n rescue => exc\n logger.error \"on_close: #{exc.message}\"\n logger.error exc.backtrace.join(\"\\n\") if exc.backtrace\n end",
"def on_close(event)\n logger.debug 'Socket closed'\n @connected = false\n @socket = nil\n dispatch('command' => 'session_ended')\n end",
"def on_close(event)\n logger.debug 'Socket closed'\n @connected = false\n @socket = nil\n dispatch('command' => 'session_ended')\n end",
"def on_client_close(client)\n end",
"def on_close(env)\n if @authenticated\n @application.stat_connection_close\n if @subscription_id\n env.logger.debug \"unsubscribe customer from channel #{@channel}\"\n @application.unsubscribe(self, @channel, @subscription_id)\n end\n end\n close_endpoint\n end",
"def close(event)\n if @deferrable\n @deferrable.fail :disconnect\n @channel.unsubscribe(@deferrable) if @channel\n end\n Firehose.logger.debug \"WS connection `#{@req.path}` closing. Code: #{event.code.inspect}; Reason #{event.reason.inspect}\"\n end",
"def disconnect\n @on_disconnected.call if @on_disconnected\n @enable_reconnection = false\n @ws.close\n end",
"def on_close\n on :close\n close\n end",
"def on_closed(&block)\n define_callback :disconnect, &block\n end",
"def on_close(env)\n @connection.destroy if @connection\n end",
"def on_close(&callback)\n @close_cb = callback\n @client.on_close(&callback) unless @client.nil?\n end",
"def sends_close\n script.sends_channel_close(self)\n end",
"def close_client(client)\n unplug_client(client)\n client[:ws].close # triggers on :close later, or after 30s timeout\n end",
"def close(reason: nil, reconnect: true)\n transmit(\n type: ActionCable::INTERNAL[:message_types][:disconnect],\n reason: reason,\n reconnect: reconnect\n )\n websocket.close\n end",
"def client_disconnected\n puts \"client #{current_user.email} disconnected\"\n current_player = current_user.player\n broadcast_message :player_exit, {\n id: current_player.id\n }\n current_player.is_online = false\n current_player.save\n end",
"def on_connection_close &block\n @connection_close_callback = block\n end",
"def close\n info { \"closing connection\" }\n socket.shutdown\n end",
"def close\n conn.write(\"(api-quit)\") if connected?\n rescue Errno::ECONNRESET\n ensure\n self.conn = nil\n end",
"def on_close\n @closebacks.each {|closeback| closeback.call}\n end",
"def client_disconnected\n end",
"def on_disconnect(client_id)\n @client_manager.remove(client_id)\n end",
"def shutdown\n client.close\n end",
"def client_quit(socket)\n @connections.delete(socket)\n socket.close\n end",
"def close &on_disconnect\n @heartbeat_timer.cancel if @heartbeat_timer\n @heartbeat_timer = nil\n if on_disconnect\n @closing = true\n @on_disconnect = proc{\n on_disconnect.call\n @closing = false\n }\n end\n\n callback{ |c|\n if c.channels.any?\n c.channels.each do |ch, mq|\n mq.close\n end\n else\n send Protocol::Connection::Close.new(:reply_code => 200,\n :reply_text => 'Goodbye',\n :class_id => 0,\n :method_id => 0)\n end\n }\n end",
"def disconnect()\r\n @callbacks.each { |block| block.call }.clear()\r\n @conn.close if @conn\r\n @conn = nil\r\n end",
"def disconnect\n @socket.close\n end",
"def connection_closed\n close\n end",
"def close()\n\t\t@connection.disconnect\n\t\t@connection = nil\n\tend",
"def close &on_disconnect\n @on_disconnect = on_disconnect if on_disconnect\n\n callback{ |c|\n if c.channels.any?\n c.channels.each do |ch, mq|\n mq.close\n end\n else\n send Protocol::Connection::Close.new(:reply_code => 200,\n :reply_text => 'Goodbye',\n :class_id => 0,\n :method_id => 0)\n end\n }\n end",
"def on_disconnect(socket)\n Utils.logger.info(\"[Client Disconnected: #{socket.inspect}]\")\n end",
"def close()\n @connection.disconnect\n @connection = nil\n end",
"def close( client_initiated=true )\n unless defined?(@already_closed) && @already_closed\n msg = @buffers.writer\n msg.write_byte CHANNEL_CLOSE\n msg.write_long @remote_id\n @connection.send_message msg\n @already_closed = true\n end\n\n unless client_initiated\n @connection.remove_channel( self )\n callback :close, self\n end\n\n self\n end",
"def on_close\n\t\tend",
"def on_shutdown(client)\n client.write \"Server shutting down. Goodbye.\"\n end",
"def close\n @log.info { \"Closing connection to client #{@ip}\" }\n @socket.close\n end",
"def on_close( channel )\n @state = :closed\n end",
"def finish\n begin\n @socket.close\n rescue\n end\n on_disconnected\n end",
"def on_shutdown\n logger.debug \"Disconnecting user: #{@user} from channel: #{@channel}.\"\n @@connections[@channel].delete(@user)\n end",
"def quit\n client.quit\n end",
"def on_close\n\tend",
"def shutdown\n @data_socket.close\n @ack_socket.close\n @client.disconnect! rescue nil\n end",
"def disconnect\n begin\n @log.info \"Closing '#{@username}' session\"\n @client.close\n @log.info \"Session closed\"\n rescue\n @log.error \"Error disconnecting '#{@username}': #{$!}\"\n end\n end",
"def close\n @socket.close\n @socket=\"\"\n end",
"def disconnect\n @thread.exit\n @client.disconnect\n @channels.clear\n end",
"def close\n @channels.each{|channel,omegle|\n omegle.send(\"You have been connected to a message bridge, which is now shutting down. Goodbye.\")\n omegle.disconnect\n }\n end",
"def close\n write_message(Vertica::Protocol::Terminate.new)\n ensure\n close_socket\n end",
"def on_disconnect(&callback)\n @disconnect_cb = callback\n @client.on_disconnect(&callback) unless @client.nil?\n end",
"def close\n client.close\n @client = nil\n end",
"def disconnect\n info 'closing connection to host'\n @connected = false\n end",
"def close\n close_connection(CLOSED, true)\n end",
"def close_connection\n current_connection.logout if current_connection?\n current_connection = nil\n end",
"def on_close(&callback)\n @close_cb = callback\n end",
"def local_disconnect(body)\n @connection.disconnect\n _network_init\n _notice \"disconnected\", :global\nend",
"def on_MainWindow_destroy\n @wfsock.close\n Gtk.main_quit\n end",
"def gets_close\n script.gets_channel_close(self)\n end",
"def close\n @socket.close\n end",
"def close\n @socket.close\n end",
"def close\n tagged_response(\"CLOSE\")\n end",
"def on_shutdown client\n controller(client).on_shutdown\n end",
"def connection_closed\n end",
"def disconnect; @connection.close end",
"def close(headers={})\n @connection.disconnect(headers)\n end",
"def close(context)\n context.debug('Logout connection')\n @connection_info = nil\n @client.logout\n @client = nil\n @system = nil\n end",
"def close()\r\n _dprint(\"Closing Auth_WiKID connection ...\")\r\n unless $sslsocket.nil?\r\n unless $sslsocket.closed?\r\n $sslsocket.puts(\"QUIT\");\r\n $sslsocket.flush\r\n $sslsocket.close\r\n end\r\n $sslsocket = nil\r\n @socket.shutdown\r\n end\r\n @isConnected = false\r\n end",
"def disconnect\n if @socket\n @socket.close\n @socket = nil\n @authed = false\n end\n end",
"def disconnect\n if @socket\n @socket.close\n @socket = nil\n @authed = false\n end\n end",
"def destroy_client(client_id, &callback)\n @connected.delete(client_id)\n @subscriptions.remove(client_id).each do |channel|\n @channels.remove(channel, client_id)\n end\n @messages.remove(client_id)\n @server.debug 'Destroyed client ?', client_id\n @server.trigger(:disconnect, client_id)\n @events.publish(\"disconnect:#{client_id}\")\n callback.call if callback\n end",
"def destroy\n @sock.cmd(\"String\"=>\"quit\")\n @sock.close\n end",
"def stop\n log \"closing connection\"\n @running = false\n client.stop!\n log \"closed\"\n end",
"def disconnect\n _logout\n @connection.close\n end",
"def close\n @socket.close\n end",
"def disconnect(kerb_client = client)\n kerb_client.close if kerb_client\n\n if kerb_client == client\n self.client = nil\n end\n end",
"def handle_close\n @sock.close\n rescue Exception\n log.error \"Connector#handle_close\"\n log.error $!\n end",
"def on_close env\n return unless env[:subscription]\n env.delete(:subscription).close_stream!\n end",
"def handle_websocket( request )\n\t\tself.log.warn \"Unhandled WEBSOCKET frame (%p)\" % [ request.headers.path ]\n\t\tres = request.response\n\t\tres.make_close_frame( Mongrel2::WebSocket::CLOSE_POLICY_VIOLATION )\n\n\t\tself.conn.reply( res )\n\t\tself.conn.reply_close( request )\n\n\t\treturn nil\n\tend",
"def on_disconnect(connection, server, reason = nil)\n end",
"def close()\n if isConnected()\n if @sentConnect\n @sentConnect = false # set in connect()\n @signedOn=false # set in signOn() inside connect()\n bye = VistaRPC.new(\"#BYE#\", RPCResponse::SINGLE_VALUE, true)\n retval = execute(bye)\n @socket.close()\n @socket = nil\n @duz = \"0\"\n @lastvistaerror = nil\n @currentContext = nil\n return retval\n end\n end\n end",
"def disconnect\n if @socket\n @socket.close\n @socket = nil\n end\n end",
"def quit\n session.connection.close\n end",
"def destroy\n @client.client.disconnect\n end",
"def on_disconnect_event(ctx)\n logger.debug(\"Client disconnect from #{ctx[:server][:remote_ip]}:#{ctx[:server][:remote_port]}\")\n end",
"def stop!\n return unless running?\n @logger.info 'Stopping WebSocket server'\n @client_mutex.synchronize do\n @clients.each do |socket, client|\n client.stop!\n end\n end\n @server_thread.kill if @server_thread\n @server.close\n end",
"def disconnect!\n @client&.close\n rescue StandardError\n nil\n end",
"def disconnect\n @tcp_socket.close\n end",
"def on_session_close(session)\n\tend",
"def make_close_frame( statuscode=Mongrel2::WebSocket::CLOSE_NORMAL )\n\t\t\tself.opcode = :close\n\t\t\tself.set_status( statuscode )\n\t\tend",
"def close_connection\n @connection.finish\n end",
"def disconnect\n @conn.close\n end",
"def disconnect\n @conn.close\n end",
"def disconnect\n @conn.close\n end",
"def disconnect\n @conn.close\n end",
"def socket_disconnected\n end",
"def on_session_close(session,reason = \"\")\n\t\t\t\tbegin\n\t\t\t\t\tprint_status(\"Session:#{session.sid} Type:#{session.type} is shutting down\")\n\t\t\t\t\tsend_direct(\"Source: #{@source} Session:#{session.sid} Type:#{session.type} is shutting down\")\n\t\t\t\trescue\n\t\t\t\t\treturn\n\t\t\t\tend\n\t\t\t\treturn\n\t\t\tend"
] |
[
"0.84952414",
"0.79038244",
"0.786516",
"0.7622504",
"0.75200546",
"0.744577",
"0.7439407",
"0.7404754",
"0.7263375",
"0.7180253",
"0.7180253",
"0.71518993",
"0.70926535",
"0.6958211",
"0.6952492",
"0.68450874",
"0.67452216",
"0.67247725",
"0.67071",
"0.67034715",
"0.66702634",
"0.66569036",
"0.6578561",
"0.6576597",
"0.6568946",
"0.65513325",
"0.65458006",
"0.6525812",
"0.6509371",
"0.65068865",
"0.6496624",
"0.6496369",
"0.6495955",
"0.6482933",
"0.64729995",
"0.64671874",
"0.64662945",
"0.6429801",
"0.64158446",
"0.64145786",
"0.6408658",
"0.640695",
"0.64013004",
"0.6396083",
"0.63909715",
"0.63857794",
"0.6355011",
"0.6323146",
"0.63223016",
"0.63202393",
"0.6309205",
"0.63055074",
"0.6302049",
"0.6288331",
"0.62742126",
"0.62556136",
"0.62461257",
"0.62106633",
"0.6198086",
"0.61970484",
"0.6188812",
"0.61873",
"0.6172806",
"0.61708915",
"0.61708915",
"0.61682266",
"0.6148946",
"0.61478734",
"0.6141429",
"0.613787",
"0.61333936",
"0.61154246",
"0.61087173",
"0.61087173",
"0.6107302",
"0.60988003",
"0.609677",
"0.60930794",
"0.60911214",
"0.608708",
"0.60832894",
"0.6079319",
"0.6071887",
"0.60717756",
"0.60651517",
"0.6064956",
"0.6021957",
"0.60204315",
"0.6016076",
"0.59946847",
"0.5994273",
"0.5991174",
"0.5983488",
"0.59797645",
"0.5972397",
"0.59721136",
"0.59721136",
"0.59721136",
"0.59721136",
"0.59701574",
"0.59691256"
] |
0.0
|
-1
|
Called when the client sends some data.
|
def received(message)
if message.respond_to?(:encoding) && message.encoding != 'UTF-8'
message.force_encoding 'UTF-8'
end
data = JSON.parse message, :symbolize_names => true
case data[:type]
when 'text'
return if @nonces.include?(data[:nonce])
@nonces << data[:nonce]
room.message @user, data[:text], name_color, data[:client_ts]
when 'av-invite', 'av-accept', 'av-close'
return if @nonces.include?(data[:nonce])
@nonces << data[:nonce]
av_message data
when 'sync'
@last_event_id = data[:last_event_id].to_i
sync_events
when 'ping'
respond pong: { nonce: data[:nonce], client_ts: data[:client_ts] }
when 'relay'
return if @nonces.include?(data[:nonce])
@nonces << data[:nonce]
room.relay @user, data[:to], data[:body], data[:client_ts]
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def send_data(data)\n super(data)\n puts \"#{self} send_data done: #{data.inspect}\"\n end",
"def send_data(data)\n super(data)\n puts \"#{self} send_data done: #{data.inspect}\"\n end",
"def send_data data\n super \"#{data}\\n\"\n Events.dispatch(:raw_out, Message.new(self, data, true))\n\n @lines_sent += 1\n @bytes_sent += data.bytesize + 1\n\n $log.debug(\"IRCConnection.send_data #{@name}\") { data }\n end",
"def send_data(data)\n super(data)\n @@log.warn \"#{self} send_data done: #{data.inspect}\"\n end",
"def send(data)\r\n @connected.callback { send_data data }\r\n end",
"def send(data)\r\n @connected.callback { send_data data }\r\n end",
"def send(data)\n @client.send(data)\n end",
"def send_data(data)\n @impl.send_data data\n end",
"def send_data(*args)\n EM.next_tick do\n @socket.send_data(*args)\n end\n end",
"def send(data)\n @conn.send serialize data\n end",
"def _send_message data\n response << data\n end",
"def send_data(data)\n logdebug \"send_data:\", :data => data\n attempt_write(data)\n end",
"def _send_data(data)\n send_data(data + \"\\r\\n\")\n end",
"def send_data(*args)\n EM.next_tick do\n @socket.send_data(*args)\n end\n end",
"def send_data( data )\n\t\tjson = data.to_json\n\t\tbytes = json.bytesize\n\t\tputs \"SEND %3i bytes to %s: %s\" % [bytes,name,json] if $DEBUG\n\t\tunless @socket.closed?\n\t\t\t@socket.write [bytes].pack('n')\n\t\t\tunless @socket.closed?\n\t\t\t\t@socket.write(json) == bytes\n\t\t\tend\n\t\tend\n\tend",
"def send_data(data)\n jsonified_data = data.to_json\n log('sending', jsonified_data)\n super(jsonified_data)\n end",
"def send_raw(data)\n # puts \"Sending data\"\n # puts_data(data)\n write(data)\n end",
"def send_data( data )\n @connection.register_data_request( self, data )\n end",
"def receive_data(data)\n log_debug { '[server] receive_data: %s' % data }\n\n @request_buffer << data\n @request_data = @request_buffer.data\n @stats.request_size = @request_buffer.size\n\n handle_client if @request_buffer.flushed?\n end",
"def receive_data(data)\n log_debug '[server] receive_data: %s' % data\n @buffer << data\n handle_client if @buffer.flushed?\n end",
"def received\n end",
"def receiving(data); end",
"def receiving(data); end",
"def send(data)\n @socket.send(data, SEND_FLAGS)\n end",
"def send_raw(data)\n socket.send_raw data\n end",
"def send_data(data)\n log.debug(\"Sent stanza:\\t\\tfrom=#{@local_addr}\\tto=#{@remote_addr}\\n#{data}\\n\")\n super\n end",
"def on_client_data(client)\n end",
"def receive_data(data)\n @client.send_command(SendDataCommand.new(@connection_id, data))\n end",
"def send_data(raw_data)\n encoded_message = encode(raw_data)\n Rails.logger.debug { \"#{Time.zone.now.getutc.inspect}: Sending to #{@socket.url}: #{encoded_message.inspect}\" }\n # Send the message to the WebSocket connection _immediately_\n # by scheduling it for the next execution of the EventMachine reactor run.\n # Otherwise, the message might be queued causing delays for users.\n EventMachine.next_tick do\n @socket.send(encoded_message)\n end\n end",
"def send_msg(data, connection)\n # TODO\n end",
"def send_event( data )\n\n\t\tuntil data.empty?\n\t\t\tbytes = self.socket.send( data, 0, self.multicast_address, self.port )\n\n\t\t\tself.log.debug \"Sent: %p\" % [ data[0, bytes] ]\n\t\t\tdata[ 0, bytes ] = ''\n\t\tend\n\tend",
"def on_message client, data\n controller(client).on_message(data)\n end",
"def send_msg(data, connection)\n # TODO\n end",
"def send_data(data)\n str_data = data.pack('C*')\n super(str_data)\n end",
"def send\n puts \"a fake implementation of `send`\"\n end",
"def send data\n data = [data.bytesize, *data.bytes].pack 'NC*'\n\n @socket.send data, 0\n end",
"def send_event( data )\n\t\tuntil data.empty?\n\t\t\tbytes = self.socket.sendmsg_nonblock( data, 0, exception: false )\n\n\t\t\tif bytes == :wait_writable\n\t\t\t\tIO.select( nil, [self.socket], nil )\n\t\t\telse\n\t\t\t\tself.log.debug \"Sent: %p\" % [ data[0, bytes] ]\n\t\t\t\tdata[ 0, bytes ] = ''\n\t\t\tend\n\t\tend\n\tend",
"def send\n @sent_at = Time.now\n sender.publish(data, meta)\n self\n end",
"def send_data(data); nil; end",
"def send_data( data )\n raise \"channel not open\" unless @state == :open\n @channel.send_data data\n end",
"def send_data hash\n raise 'not implemented'\n end",
"def sends_data(data)\n script.sends_channel_data(self, data)\n end",
"def write(msg)\n\t\t\t\t# object should implement send_data\n\t\t\t\traise \"Abstract method called\"\n\t\t\tend",
"def receive_data(data)\n log \"<< #{data.size}\"\n @write_to_channel << data\n end",
"def on_send_response(cli,data)\n cli.payload = data\n cli.recalc\n inject cli.to_s\n sent_info(cli,data) if datastore['VERBOSE']\n end",
"def send(data, opt={:type => :text})\n puts \"send ***************\"\n return if !@handshaked or @closed\n puts \"after send************\"\n type = opt[:type]\n frame = ::WebSocket::Frame::Outgoing::Client.new(:data => data, :type => type, :version => @handshake.version)\n begin\n @socket.write frame.to_s\n rescue Errno::EPIPE => e\n @pipe_broken = true\n emit :__close, e\n end\n end",
"def send_data(data)\n case data\n when nil\n put_string(\"NIL\")\n when String\n send_string_data(data)\n when Integer\n send_number_data(data)\n when Array\n send_list_data(data)\n when Time\n send_time_data(data)\n when Symbol\n send_symbol_data(data)\n else\n data.send_data(self)\n end\nend",
"def send!\n @_sended = true\n self\n end",
"def receive_data data\n rdata = data.split(\"\\n\")\n rdata.each do |line|\n puts \"#{self} received <<< #{line}\"\n # the echo part\n send_data \">>>you sent: #{line}\\n\"\n # Close the connection when the client tells us to.\n close_connection if line =~ /quit/i\n end\n end",
"def send(data)\n debug [:send, data]\n send_data(\"\\x00#{data}\\xff\")\n end",
"def send(data)\n debug [:send, data]\n send_data(\"\\x00#{data}\\xff\")\n end",
"def send_data( type, data )\n data = data.to_s\n\n msg = @buffers.writer\n msg.write_long data.length + 1\n msg.write_byte type\n msg.write data\n\n @channel.send_data msg\n end",
"def send_data(data)\n case data\n when nil\n put_string(\"NIL\")\n when String\n send_string_data(data)\n when Integer\n send_number_data(data)\n when Array\n send_list_data(data)\n when Time\n send_time_data(data)\n when Symbol\n send_symbol_data(data)\n when EM::IMAP::Command\n send_command(data)\n else\n data.send_data(self)\n end\n end",
"def receive_data(data)\n\n if data.match 'SOURCE'\n p data\n send_data(\"HTTP 200 OK\\r\\n\\r\\n\")\n else\n # require 'pry'; binding.pry\n p data.size\n @channel.push(data.bytes)\n end\n end",
"def send_data data\n\t size = data.bytesize if data.respond_to?(:bytesize)\n\t size ||= data.size\n\t\tEventMachine::send_data @signature, data, size\n\tend",
"def send_data(data)\n \n return nil if @connection.nil? or data.nil? or data.empty? \n \n begin\n @connection.send(data, 0)\n puts \"#{self.class} send to #{@tcp_ip}:#{@tcp_port} this: #{data.to_hex}\" if $debug\n rescue\n @connection = nil\n return nil\n end\n \n end",
"def send_msg(data)\n @send_lock.synchronize{\n TCP.em.schedule { send_data(data) }\n }\n end",
"def send_data_impl(*args)\n puts \"send(#{args[0]})\" if $verbose\n event_list = []\n data = []\n args[0].each do |x|\n # if hashring is not nil this is valid metric\n if x[:hashring] != nil\n @@message_queue << {\n :hashring => x[:hashring],\n :timestamp => Time.now.to_f,\n :data => x[:data]\n }\n end\n data << x[:data]\n event_list << x[:event]\n end\n @expected_events << event_list\n @data_socket.send(data.join(\"\\n\") + \"\\n\", 0, '127.0.0.1', SR_DATA_PORT)\n end",
"def receive(data); end",
"def send_data(pipe, data)\n pipe.write(data, \"\\n#{MSG_ENDI}\\n\")\nend",
"def receive_data data\n #puts \"receive data #{data.dump} |(#{data.length})\"\n if data.length == 0\n close\n end\n @response_data += data\n remaining_unhandled_data = handle_data @response_data\n @response_data = remaining_unhandled_data\n end",
"def send_msg(data, connection)\n connection.send_msg(data)\n end",
"def receive_data(data)\n end",
"def execute\n previous_time = Time.now\n\n publish_message(message(@channel, @data))\n\n @response_time = (Time.now - previous_time) * 1000 # Miliseconds\n @response_code = 1\n rescue Exception => e\n @response_code = @response_time = nil\n @response_body = e.message\n end",
"def write(rawmsg)\r\n @connection.send(rawmsg)\r\n end",
"def send_message(message)\n socket.enqueue_packet(message)\n end",
"def write(data)\n #@sock.write(data)\n\tputs \"channel data: #{str2hex(data)}\"\n end",
"def on_message_complete\n send_response\n close_socket\n write_to_screen\n end",
"def process_heartbeats(data, reply, subject)\n # No payload assumed, just reply to the heartbeat.\n nats.publish(reply, '')\n end",
"def send(message)\n ## empty\n end",
"def send\n if @accepted then\n # Calculate content length before sending\n \n @headers << \"Content-Length: #{@buffer.length}\\r\\n\"\n \n if !@content_type then\n @headers << \"Content-Type: text/html\\r\\n\"\n end\n\n # Send our data and close the connection\n @server.puts @headers\n @server.puts \"\\r\\n\"\n @server.puts @buffer\n @server.close\n else\n puts \"[Rsws] ERROR: Trying to send response without first accepting it\"\n end\n end",
"def receive_data(data)\n @in << data\n send(@state)\n rescue => e\n handle_error(e)\n end",
"def send_message(data, flag, host, port)\n\t\tsocket = UDPSocket.new\n\t\tserialized = Marshal.dump(data)\n\t\tsocket.send serialized, flag, host, port\n\t\tsocket.close\n\t\tputs \"Sending #{data} to #{host}:#{port}\"\n\t\tsleep(0.025)\n\tend",
"def receive_data data\n # The first message from the user is its name\n @name ||= data.strip\n\n @@connections.each do |client|\n # Send the message from the client to all other clients\n client.send_data \"#{@name} says: #{data}\"\n end\n end",
"def on_message data\n\t\t\tbroadcast :_push, data\n\t\t\t_push \"your message was sent: #{data.to_s}\"\n\t\tend",
"def on_packet(client_id, data, channel)\n handle_connection(client_id, data, channel)\n end",
"def receive_data_command\n @headers_finished = false\n @body = []\n @headers = {}\n\n return true\n end",
"def on_message_data_event(ctx); end",
"def receive_data(data)\n\t\t$logger.warn(\"receive_data() not implemented\")\n\tend",
"def receive_data(data)\n @write_to_channel << data\n end",
"def send_all(event, data)\n\t\tEM.next_tick {\n\t\t\t@sockets.each do |s|\n\t\t\t\ts.send(event, data) \n\t\t\tend\n\t\t}\n\tend",
"def send_request; end",
"def receive_data(data)\n split_data = data.split(\"\\n\")\n @received = @received + split_data\n @@log.warn \"#{self} receive_data ...\"\n @@log.debug \"#{self} \\n<<<#{data}>>>\"\n end",
"def received message, headers={}\n end",
"def dispatch_event(data)\n puts \"Event Dispatcher Invoked\"\n \n unless !data.has_key? \"type\"\n puts \"message type #{data['type'].to_s}\"\n \n # switch event action based on message type\n case data['type']\n when \"register\"\n puts \"user wishes to register. check auth_key first\"\n self.register(data)\n when \"subscribe\"\n puts \"user wishes to subscribe to a channel\"\n self.subscribe(data)\n when \"message\"\n # message: to:channel,from:uuid,type:message,text:message,visibility:private\n puts \"user wishes to send a message\"\n end\n \n else\n # if the socket is connected but no post_init data was sent\n # then we want to kill the connection, since this is probably an unauthorized\n # user....\n \n puts \"data doesn't have key type\"\n self.close_connection_after_writing\n end\n \n end",
"def receive_data data\n\t\tputs \"............>>>#{data.length}\"\n\tend",
"def receive_data(data)\n logdebug \"receive_data:\", :data => data\n end",
"def send_and_get_data data\n send_data data\n get_data_with_timeout data.size\n end",
"def on_message_data_event(ctx) end",
"def send( data )\n # Final text data header:\n header = 0b10000001\n\n # Payload size to use (data will always be unmasked):\n size = \"#{data}\".size\n\n # Standard payload:\n if size < 126 then\n @connection.write [ header, size, \"#{data}\" ].pack \"C2A#{size}\"\n\n # 16-bit extended payload:\n elsif size <= 65535 then\n bytes = [ size ].pack( \"S\" ).unpack( \"C2\" ).reverse.map( &:to_i )\n @connection.write [ header, 126, *bytes, \"#{data}\" ]\n .pack \"C4A#{size}\"\n\n # 64-bit extended payload:\n else\n bytes = [ size ].pack( \"S\" ).unpack( \"C8\" ).reverse.map( &:to_i )\n @connection.write [ header, 127, *bytes, \"#{data}\" ]\n .pack \"C10A#{size}\"\n end\n end",
"def do_data( data )\n @log.debug \"[#{@id}] got #{data.length} bytes\" if @log.debug?\n\n @data << data\n @progress_callback[@data] if @progress_callback\n\n if @length < 0 || @data.length < @length\n if @length < 0\n length = @chunk_size\n else\n length = @length - @data.length\n length = length > @chunk_size ? @chunk_size : length\n end\n\n @log.debug \"[#{@id}] requesting #{length} more bytes\" if @log.debug?\n @driver.read @id, @handle, @offset + @data.length, length\n @session.register( @id, self )\n else\n @callback[ OK, @data ]\n end\n end",
"def send_pending; end",
"def send_data(data, options = T.unsafe(nil)); end",
"def receive_data data\n rdata = data.split(\"\\n\")\n rdata.each do |line|\n puts \"#{self} received <<< #{line}\"\n # the echo part\n send_data \">>>you sent: #{line}\\n\"\n close_connection if line =~ /quit/i\n end\n end",
"def connection_completed\n# @keepalive = EM::PeriodicTimer.new(60) { send_data ' ' }\n start\n end",
"def send_data(body)\n @body_callback.call body\n end",
"def send! data\n send_output_io! data if @output_io || host\n send_log_io! data if log_io\n self\n end",
"def send_data(value)\r\n msg = \"#{value.chop}\\r\\n\"\r\n @socket.print(msg)\r\n end",
"def send(message)\n\t\t\t@conn.send(message)\n\t\tend",
"def send msg\n @sending_socket.send(msg)\n\n if block_given? || @handler\n messages = response\n if !messages.nil?\n messages.each do |message|\n if block_given?\n yield message\n else\n @handler.handle message\n end\n end\n end\n end\n end",
"def process_client(client, buffer); end"
] |
[
"0.7275672",
"0.7275672",
"0.7193808",
"0.6983931",
"0.6962535",
"0.6962535",
"0.6922989",
"0.6902052",
"0.6883058",
"0.6834015",
"0.68314976",
"0.68106854",
"0.6772976",
"0.6769789",
"0.67508185",
"0.6749107",
"0.6701254",
"0.66909736",
"0.6676307",
"0.66644526",
"0.66466415",
"0.6604126",
"0.6604126",
"0.66036767",
"0.6539315",
"0.6536865",
"0.65309316",
"0.65225476",
"0.650493",
"0.64644283",
"0.6464088",
"0.64640516",
"0.6424139",
"0.6390191",
"0.63532346",
"0.635305",
"0.6346624",
"0.6315178",
"0.6303423",
"0.6302145",
"0.6285295",
"0.62827975",
"0.6279211",
"0.62649924",
"0.62495965",
"0.6225431",
"0.62227976",
"0.6197638",
"0.61833376",
"0.6172983",
"0.6172983",
"0.6149729",
"0.61416686",
"0.6133889",
"0.6126361",
"0.6121862",
"0.61195815",
"0.61107236",
"0.608465",
"0.60821843",
"0.6080617",
"0.6069843",
"0.6055352",
"0.6041515",
"0.6029237",
"0.602921",
"0.60087126",
"0.5999718",
"0.59964055",
"0.5995067",
"0.59949386",
"0.59792185",
"0.597592",
"0.5972329",
"0.59673643",
"0.59654987",
"0.5960724",
"0.5960094",
"0.59551466",
"0.5949085",
"0.5947803",
"0.5932575",
"0.59294647",
"0.5916804",
"0.5913562",
"0.59123",
"0.5910708",
"0.59060663",
"0.5901194",
"0.5897752",
"0.5897739",
"0.5896441",
"0.58951735",
"0.58879936",
"0.58856523",
"0.58785886",
"0.5877582",
"0.58754325",
"0.58724314",
"0.5859335",
"0.58590287"
] |
0.0
|
-1
|
Called by received to process A/V events.
|
def av_message(message_data)
case message_data['type']
when 'av-invite'
@av_nonce = message_data[:av_nonce]
when 'av-accept'
# NOTE: room#av_event takes care of av-accept
when 'av-close'
@av_nonce = nil if @av_nonce == message_data[:av_nonce]
end
room.av_event @user, message_data[:type], message_data[:av_nonce],
@name_color, message_data[:client_ts]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def received\n end",
"def processEvent(eventName)\n\tend",
"def on_bytes(ev)\n\t\tclient = @clients[ev.src_addr]\n\t\t# client can only be 0 if it's a connect packet\n\t\tpost_event bytes_to_event(client,ev.bytes)\n\tend",
"def process\n read_events.each {|event| event.callback!}\n end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def ev_do_postprocess(was_events); end",
"def receiving(data); end",
"def receiving(data); end",
"def ev_do_handle_events(readers, writers); end",
"def send_events; end",
"def send_events=(_arg0); end",
"def event; end",
"def event; end",
"def event; end",
"def events=(_); end",
"def handle_event(event)\n\n\t\tend",
"def process_event(res, event_type, app_id, msg)\n logger.info \"Frisbeed: App Event from '#{app_id}' - #{event_type}: '#{msg}'\"\n if event_type == 'EXIT' #maybe i should inform you for every event_type.\n res.inform(:status, {\n status_type: 'FRISBEED',\n event: event_type.to_s.upcase,\n app: app_id,\n exit_code: msg,\n msg: msg\n }, :ALL)\n elsif event_type == 'STDOUT'\n res.inform(:status, {\n status_type: 'FRISBEED',\n event: event_type.to_s.upcase,\n app: app_id,\n exit_code: msg,\n msg: msg\n }, :ALL)\n end\n end",
"def process_event(res, event_type, app_id, msg)\n logger.info \"Frisbeed: App Event from '#{app_id}' - #{event_type}: '#{msg}'\"\n if event_type == 'EXIT' #maybe i should inform you for every event_type.\n res.inform(:status, {\n status_type: 'FRISBEED',\n event: event_type.to_s.upcase,\n app: app_id,\n exit_code: msg,\n msg: msg\n }, :ALL)\n elsif event_type == 'STDOUT'\n res.inform(:status, {\n status_type: 'FRISBEED',\n event: event_type.to_s.upcase,\n app: app_id,\n exit_code: msg,\n msg: msg\n }, :ALL)\n end\nend",
"def events\n end",
"def get_event_callback\n Proc.new do |new_packets, refCon_ptr, connRefCon_ptr|\n begin\n # p \"packets received: #{new_packets[:numPackets]}\"\n timestamp = Time.now.to_f\n messages = get_messages(new_packets)\n # SINM ADDED\n @queue.push(messages.map do |message|\n enqueue_message(message, timestamp)\n end.compact)\n # SINM COMMENTED OUT\n # messages.each { |message| enqueue_message(message, timestamp) }\n rescue Exception => exception\n Thread.main.raise(exception)\n end\n end\n end",
"def process(event)\n # Nothing\n end",
"def receive(data); end",
"def apply(raw_event); end",
"def process_events(events)\n @card_events = events.select(&:card?) \n events \n end",
"def handle_etf_message(data)\n data = Vox::ETF.decode(data)\n LOGGER.debug { \"Emitting #{OPCODES[data[:op]]}\" } if OPCODES[data[:op]] != :DISPATCH\n\n @session.seq = data[:s] if data[:s]\n op = OPCODES[data[:op]]\n\n emit(op, data)\n end",
"def process_event(cal, channel, offset, etype) \r\n cid = LocalChannel.get_channel_by_name(channel).flatten 1 # get correct channels for events\r\n cid.map {|ch| add_event(cal, ch.channelID, offset, etype)} # add event to system\r\n end",
"def handle_inbound(event_payload)\n head(:ok)\n end",
"def captureEvent(c)\n c.read\nend",
"def on_message_data_receiving_event(ctx) end",
"def handle(msg)\n msg_obj = Octo::Message::Message.new(msg)\n msg = msg_obj.to_h\n begin\n eventName = msg[:event_name]\n if (valid_events.include?eventName)\n call_hooks(eventName, msg)\n end\n rescue Exception => e \n puts e.message\n puts e.backtrace.inspect\n end\n end",
"def process_event(event)\n if(event.type == AndroidDebug::Jpda::Event::ENTRY or\n event.type == AndroidDebug::Jpda::Event::EXIT)\n on_break(event)\n elsif(event.type == AndroidDebug::Jpda::Event::VM_EXIT)\n puts(\"The VM was disconnected.\")\n exit(0)\n else\n $DEBUG and puts(\"Received unknown event type: #{event}\")\n end\n end",
"def interprete event\n @start ||= event.timestamp\n case event\n when UsbMon::Submission then interprete_submission event\n when UsbMon::Callback then interprete_callback event\n when UsbMon::Error then interprete_error event\n else\n raise \"Unknown event class #{event.class}\"\n end\n end",
"def on_response( event )\n # You can access the response data being received using the event object:\n #\n # event.data.gsub!( 'SOMETHING', 'ELSE' )\n #\n #BetterCap::Logger.raw \"\\n#{BetterCap::StreamLogger.hexdump( event.data )}\\n\"\n BetterCap::Logger.info \"No response is working fine!\"\n end",
"def handleRequest\n loop{\n puts \"User Session Listening\"\n clientMessage = @SocketHandle.gets\n clientMessage.chomp!\n \n case clientMessage\n \n when /viewall/i \n viewAllEvents\n \n when /bookevent/i\n spl = clientMessage.split\n eventid = spl[1] \n qty = spl[2] \n bookEvent @UserID, eventid, qty\n\n when /help/i\n helpCommand\n\n else \n errorCommand\n \n end \n }\n end",
"def process()\n\n\t\tputs 'OK:ft:Got raw-bytes-signal from Trigger '\n\n\t\tSssSEMapp.oIOframeHandler.writeRawBytes(@sBuffer)\n\n\t\t# clear buffer and return self\n\t\tsuper()\n\n\tend",
"def on_message_data_event(ctx); end",
"def handle\n puts \"***************************\"\n puts \"HANDLING EVENT: #{@event.inspect}\"\n puts \"***************************\"\n\n # Pass event off to handlers based on event name/title\n if @event.title == \"Out of range\"\n DeviceOutOfRangeHandler.new(@event).handle\n elsif @event.title == \"In Range\"\n DeviceWithinRangeHandler.new(@event).handle\n end\n end",
"def on_message_data_event(ctx) end",
"def callwide_events()\n on :event => 'error', :next => '/error.json' # For fatal programming errors. Log some details so we can fix it\n on :event => 'hangup', :next => '/hangup.json' # When a user hangs or call is done. We will want to log some details.\nend",
"def process(data)\n\t\tdata.each_slice(4) do |m, sec, usec, args|\n process_one_event(m, sec, usec, args)\n\t\tend\n has_event_propagation_updates? || has_structure_updates?\n\t end",
"def ev_preprocess(&block); end",
"def ev_preprocess(&block); end",
"def callback\n def_deferr = ::EventMachine::DefaultDeferrable.new\n proc_callback = Proc.new { |response| ::OnesnooperServer::Log.debug(\n \"[#{self.class.name}] Handled as: #{response}\"\n ) }\n\n def_deferr.callback &proc_callback\n def_deferr.errback &proc_callback\n\n def_deferr\n end",
"def receive_data(data)\n @buffer.extract(data).each do |line|\n payload = { :uuid => @uuid, \n :message => line,\n :host => @host,\n :user => @user }\n @global_history_fanout.publish(payload.to_json)\n end\n end",
"def handle_frame(*params)\n video = connection.receive_data\n publish(event_topic_name(\"update\"), \"video\", video)\n publish(event_topic_name(\"frame\"), video.frame)\n end",
"def process()\n\n\t\t# first byte holds the address\n\t\ti = @sBuffer[0]\n\n\t\t# nil == i that would mean buffer is empty -> should never happen\n\t\treturn super if i.nil?\n\n\t\t# convert byte-value to natural-value\n\t\ti = i.chr.to_i\n\n\t\t# no broadcast possible as we are using natural chars instead of byte-value\n\t\t# and are looking at only 1 char\n#TODO: allow 0 to 9 and map eg 9 to broadcast\n\t\t# abort if not a valid ID\n\t\treturn super if !((0..3).member?(i)) # if invalid ID\n\n\t\t# target serial ID\n\t\tiFDD = i\n\n\t\tsBasename = File::basename(@sPathFile)\n\n\t\t# second byte holds the command\n\t\ti = @sBuffer[1]\n\n\t\tcase i.chr\n\t\t\twhen 'u'\n\t\t\t\t# set duration\n\t\t\t\tsData = 'u'\n\n\t\t\t\t# read duration\n\t\t\t\ti = @sBuffer[2..-1].to_i\n\n\t\t\t\t# if not a valid duration, clear buffer\n\t\t\t\treturn super if (1 > i)\n\n\t\t\t\tputs 'OK:ft:Got set-timer-duration-signal from Trigger ' << sBasename + ' for FDD ' << iFDD.to_s << ' value: ' << i.to_s\n\n\t\t\t\t# append 4 bytes\n\t\t\t\tsData << ((i >> 24) & 0xFF) << ((i >> 16) & 0xFF)\n\t\t\t\tsData << ((i >> 8) & 0xFF) << (i & 0xFF)\n\n\t\t\twhen 'v'\n\t\t\t\t# start timer\n\t\t\t\tputs 'OK:ft:Got start-timer-signal from Trigger ' << sBasename + ' for FDD ' << iFDD.to_s\n\n\t\t\t\tsData = 'v'\n\n\t\t\twhen 'V'\n\t\t\t\t# stop timer\n\t\t\t\tputs 'OK:ft:Got stop-timer-signal from Trigger ' << sBasename + ' for FDD ' << iFDD.to_s\n\n\t\t\t\tsData = 'V'\n\n\t\t\telse\n\n\t\t\t\t# if not a valid command, clear buffer\n\t\t\t\tputs 'KO:ft: Got invalid-timer signal from Trigger ' << sBasename\n\t\t\t\treturn super\n\n\t\tend # switch case\n\n\t\tSssSEMapp.oIOframeHandler.writeFramed(iFDD, sData)\n\n\t\t# clear buffer and return self\n\t\tsuper\n\n\tend",
"def dispatch_event(data)\n puts \"Event Dispatcher Invoked\"\n \n unless !data.has_key? \"type\"\n puts \"message type #{data['type'].to_s}\"\n \n # switch event action based on message type\n case data['type']\n when \"register\"\n puts \"user wishes to register. check auth_key first\"\n self.register(data)\n when \"subscribe\"\n puts \"user wishes to subscribe to a channel\"\n self.subscribe(data)\n when \"message\"\n # message: to:channel,from:uuid,type:message,text:message,visibility:private\n puts \"user wishes to send a message\"\n end\n \n else\n # if the socket is connected but no post_init data was sent\n # then we want to kill the connection, since this is probably an unauthorized\n # user....\n \n puts \"data doesn't have key type\"\n self.close_connection_after_writing\n end\n \n end",
"def receive_axfr(soa_resource)\n done\n end",
"def extract_message(msg)\n case msg['event']\n when \"playerStateChange\", \"playerQualityChange\", \"playerReady\", \"pageLoaded\"\n @events << ProbeEvent.new(msg['event'], msg['timestamp'], msg['data'])\n when \"videoDuration\"\n @video_duration = msg['data'].to_i\n when \"finished\"\n calculate_results\n # TODO what to do with the probe?\n # close the page?\n end\n end",
"def processEvent( client, user, t_event )\n#\t\tclient.room.say(\"Processing Event #{t_event}\")\n if user.id != client.user.id\n $botData['events'].each { |event|\n if event['event'] == t_event\n if event['delivery_method'].to_i == 1\n if event['include_name'].to_i == 0\n client.room.say(event['pre_text'] + event['post_text'])\n else\n client.room.say(event['pre_text'] + user.name + event['post_text'])\n end\n else\n if event['include_name'].to_i == 0\n user.say(event['pre_text'] + event['post_text'])\n else\n user.say(event['pre_text'] + user.name + event['post_text'])\n end\n end\n end\n }\n end\nend",
"def EVIOCSREP; _IOW('E', 0x03, unsigned_int_2);end",
"def event_bus; end",
"def event_bus; end",
"def handle_readable_io_event( event )\n\t\tself.log.debug \"Got socket read event: %p\" % [ event ]\n\t\tmsg = event.socket.receive\n\t\ttype, data, header = Assemblage::Protocol.decode( msg )\n\n\t\tunless HANDLED_MESSAGE_TYPES.include?( type )\n\t\t\tself.log.error \"Got unhandled message type %p\" % [ type ]\n\t\t\traise \"Invalid action %p!\" % [ type ]\n\t\tend\n\n\t\tmethod_name = \"on_%s_message\" % [ type ]\n\t\thandler = self.method( method_name )\n\t\thandler.call( data, header )\n\tend",
"def on_vcall(_args, rest)\n # Seriously - discard args. Maybe process rest?\n process(rest)\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 event_incoming_client_control(client, peer, cmd, *args)\nend",
"def receive_data(data)\n end",
"def process!\n events.each(&:process!)\n end",
"def on_message(event)\n data = if @inflate\n packed = event.data.pack('c*')\n @inflate << packed\n return unless packed.end_with?(ZLIB_SUFFIX)\n\n @inflate.inflate('')\n else\n event.data\n end\n\n LOGGER.debug { \"[IN] #{data[0].ord == 131 ? data.inspect : data}\" }\n emit(:message, data)\n end",
"def signal_received; end",
"def listen(p0) end",
"def listen(p0) end",
"def listen(p0) end",
"def parse_event(event)\n if ((event[:type] == 376) || (event[:type] == 422)) && !@connected\n @connected = true\n process_callbacks(:connect, event)\n end\n\n process_callbacks(event[:type], event)\n end",
"def EVIOCGSND(len); _IOC(_IOC_READ, 'E', 0x1a, len);end",
"def receive(request); end",
"def work(raw_event)\n event = JSON.parse(raw_event)\n EventManager.new.handle_event(event)\n end",
"def bind_events\n PARSER_EVENTS.each do |e|\n @client.on(e){|*a| __send__ \"on_#{e}\", *a}\n end\n end",
"def on_verack\n log.debug { \">> verack\" }\n complete_handshake if outgoing?\n end",
"def event \n begin \n outlet \n if current_user[:statusCode].blank? || current_user[:statusCode]==0\n input = {\"user\"=>{\"userId\"=>current_user[:value].userId}} \n\t logger.info(\"ItemController::Event::Input----#{input}\")\n @events_info = smvGetEventsByUser(input, request.env) \n @smv_status = {\n :statusCode => @events_info.statusCode,\n :value => @events_info.value, \n\t :msg => @events_info.message\n }\n else\n @smv_status = {\n :statusCode => -1,\n :value => '', \n\t :msg => \"No User Found\"\n }\n end\n logger.info(\"ItemController::Event::----#{@smv_status}\")\n @numberOfInactiveEvents =0\n if !@smv_status.blank? && @smv_status[:statusCode]==0\n @smv_status[:value].each do |event|\n if event.status.downcase != I18n.t(\"constant.event_active\").downcase\n @numberOfInactiveEvents = @numberOfInactiveEvents + 1\n end\n end\n end\n logger.info(\"ItemController::Event::number of inactive events----#{@numberOfInactiveEvents}\")\n \n rescue Exception => exc\n @error_message = I18n.t(\"message.event_fetch_error\")\n @smv_status = {\n :statusCode => -1,\n :value => '', \n\t :msg => \"Java API error occured::#{@error_message}::#{exc.message}\"\n } \n logger.error(\"ItemController::Event-----#{@smv_status}\") \n end\n return @smv_status\n end",
"def event_incoming_clients_control(client, cmd, *args)\nend",
"def event_callback\n case params[:event][:type]\n when \"message\"\n parse_message\n when \"app_mention\"\n end\n end",
"def arrive(e)\n ch = get_object(e.msg)\n # add character\n add_contents(ch.id)\n ch.location = id\n characters(e.msg).each do |x|\n add_event(id,x.id,:show, ch.name+\" has arrived.\") if x.account\n end\n ch.parse('look')\n end",
"def let_go\n # And now here comes the events\n octo.grab \"push\" do |events|\n events.each_pair do |path, evts|\n evts.select! {|evt| Time.parse(evt[\"created_at\"]).getlocal(\"+08:00\").within_deadline?}\n # Since the text length can be no longer than 65536, split it just in case\n count = (JSON.dump(evts).length / MSG_SIZE_LIMIT) + 1\n slice_size = evts.length / count\n evts.each_slice(slice_size) do |partial|\n obj = {\n \"path\" => path,\n \"evts\" => partial\n }\n\n @queue.send_message(JSON.dump(obj))\n end\n end\n end\n end",
"def decode_event(exi_event_code)\n end",
"def received message, headers={}\n end",
"def answer(evt , vote)\n puts \"Eviando dados ...\"\n payload = \"{\\\"ANS\\\":\\\"%s\\\",\\\"VOTE\\\":%d }\" % [evt,vote]\n puts \"PAYLOAD: \" + payload\n @carrier.send( payload )\n end",
"def receive_data(data)\n handle(data)\n end",
"def on(event, &block) # open, message, close, ping, pong\n @events[event] = block\n end",
"def receive_data &block\n self.on_data_received = block\n end",
"def received(message)\n if message.respond_to?(:encoding) && message.encoding != 'UTF-8'\n message.force_encoding 'UTF-8'\n end\n data = JSON.parse message, :symbolize_names => true\n\n case data[:type]\n when 'text'\n return if @nonces.include?(data[:nonce])\n @nonces << data[:nonce]\n room.message @user, data[:text], name_color, data[:client_ts]\n when 'av-invite', 'av-accept', 'av-close'\n return if @nonces.include?(data[:nonce])\n @nonces << data[:nonce]\n av_message data\n when 'sync'\n @last_event_id = data[:last_event_id].to_i\n sync_events\n when 'ping'\n respond pong: { nonce: data[:nonce], client_ts: data[:client_ts] }\n when 'relay'\n return if @nonces.include?(data[:nonce])\n @nonces << data[:nonce]\n room.relay @user, data[:to], data[:body], data[:client_ts]\n end\n end",
"def receive_response(response); end",
"def onData(data,_chan,_event)\n id = @config[:radix][:id]\n me = \"#{id}/#{__method__}\" \n @log.info(\"[#{me}]\")\n begin\n dec = dechan(data,_chan,_event)\n @log.debug(\"[#{me}] data size: #{dec.to_s.size}\")\n rescue Exception => ex\n @log.debug(\"[#{me}] data error: #{ex.inspect}\") \n end\n # TODO: send to the local queue and to dashing\n end",
"def handle_update\n navdata = connection.receive_data\n publish(event_topic_name(\"update\"), navdata)\n end",
"def upcaming_events\n self.attended_events.upcaming\n end",
"def event(msg)\n unknown(\"=====> #{msg}\")\n end",
"def on_message_data_start_event(ctx) end",
"def events\n # ignore messages from bots!\n\n case params[:type]\n when 'url_verification'\n logger.info \"verifying url\"\n render json: { challenge: params[:challenge] }\n when 'event_callback'\n return unless event_params[:bot_id].nil?\n\n render json: nil\n ProcessSlackMessageJob.perform_later(event_params.as_json)\n\n else\n logger.info '*'*10\n logger.info \"Unknown event type: #{params[:type]}\"\n logger.info params.inspect\n end\n end",
"def human_event; end",
"def on_message(event)\n message = JSON.parse(event.data)\n\n if message['id']\n message['command'] = 'response_received'\n elsif message['message']\n command, *args = *message['message']\n message = {'command' => command, 'args' => args}\n end\n\n logger.debug \"Message received: #{message.inspect}\"\n dispatch(message)\n end",
"def process_events\n until @dead\n event = next_event\n notify_listeners(event)\n event.dispatch\n end\n rescue Exception => ex\n Logger.error \"Error while running event: #{Logger.format_error(ex)}\"\n end",
"def listener; end"
] |
[
"0.6694836",
"0.6279749",
"0.5963906",
"0.5909283",
"0.58486754",
"0.58486754",
"0.58486754",
"0.58486754",
"0.58486754",
"0.58486754",
"0.58486754",
"0.58486754",
"0.58278257",
"0.5823451",
"0.5823451",
"0.5823276",
"0.5802523",
"0.5732461",
"0.57003206",
"0.57003206",
"0.57003206",
"0.5694021",
"0.56790763",
"0.5563337",
"0.5560604",
"0.55480146",
"0.55415994",
"0.5506791",
"0.55027854",
"0.5492052",
"0.54850596",
"0.54841894",
"0.5473308",
"0.546969",
"0.54668266",
"0.5464575",
"0.54600626",
"0.5429878",
"0.54090774",
"0.5407096",
"0.5402715",
"0.5398292",
"0.5351063",
"0.5343169",
"0.5336749",
"0.5333167",
"0.5328875",
"0.5324609",
"0.5324609",
"0.530808",
"0.53048056",
"0.5300244",
"0.52842706",
"0.52841866",
"0.52823913",
"0.528047",
"0.52786684",
"0.527188",
"0.5264287",
"0.5264287",
"0.5264132",
"0.52578765",
"0.5242747",
"0.5242191",
"0.5222598",
"0.52187735",
"0.5215855",
"0.521499",
"0.5211447",
"0.5211447",
"0.5211447",
"0.52098805",
"0.52075696",
"0.52002",
"0.51913774",
"0.5186241",
"0.51822466",
"0.51774675",
"0.5174653",
"0.51725966",
"0.51722616",
"0.51653284",
"0.51628774",
"0.51562077",
"0.51526237",
"0.5148375",
"0.51471967",
"0.51388705",
"0.51378155",
"0.5132383",
"0.5131282",
"0.5130788",
"0.5095717",
"0.5085371",
"0.50832635",
"0.50831574",
"0.50744283",
"0.5070453",
"0.50683576",
"0.50675505"
] |
0.5918022
|
3
|
The color of this user's messages.
|
def name_color
# HACK(pwnall): come up with better colors
user.key == @room.user1.key ? 'red' : 'blue'
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_user_text_color(user)\n user_color = get_user_color(user).gsub(\"#\", \"\")\n\n # Get the hex color as red, green, blue\n r = user_color[0..1].hex\n g = user_color[2..3].hex\n b = user_color[4..5].hex\n\n if ((r * 0.299) + (g * 0.587) + (b * 0.114)) > 186\n \"#4a4a4a\"\n else\n \"#ffffff\"\n end\n end",
"def color\n return @color\n end",
"def color\n return @color\n end",
"def textColor\n return @text_color\n end",
"def get_color\n @color\n end",
"def color\n\t\treturn @color\n\t\t\n\tend",
"def status_color\n if self.success && self.error_text.nil?\n return 'green'\n elsif self.success\n return 'yellow'\n else\n return 'red'\n end\n end",
"def color\n @data[:color]\n end",
"def get_user_color(user)\n require \"digest/md5\"\n \"##{Digest::MD5.hexdigest(user.name)[0..5]}\"\n end",
"def textColor(theColor, target = nil)\n return if theColor.nil?\n views = @alert.window.contentView.subviews # the standard label fields\n case target\n when 'message' then views[4].textColor = MEalert.getColor(theColor, 'textColor')\n when 'informative' then views[5].textColor = MEalert.getColor(theColor, 'textColor')\n else @coloration[:text] = theColor\n end\n end",
"def color\n\t\t \t\t\t\"El color de tu vaca es #{@color}\"\n\t\t \t\tend",
"def user_color(user_id)\n User.find(user_id).color\n end",
"def color\n return @color\n end",
"def output_message message, color\n case color\n when :black\n puts message.black\n when :red\n puts message.red\n when :green\n puts message.green\n when :yellow\n puts message.yellow\n when :blue\n puts message.blue\n when :magenta\n puts message.magenta\n when :cyan\n puts message.cyan\n else\n puts message\n end\n end",
"def color\n @attributes[:color]\n end",
"def color\n @red ? \"R\" : \"B\"\n end",
"def color\n\t\tif name == \"Broken\"\n\t\t\tcolor = \"red\"\n\t\telsif name == \"Needs Attention\"\n\t\t\tcolor = \"orange\"\n\t\telsif name == \"Working\"\n\t\t\tcolor = \"green\"\n\t\telse\n\t\t\tcolor = \"\"\n\t\tend\n\t\treturn color\n end",
"def get_color\n completed? ? 'info' : 'warning'\n end",
"def color\n @color\n end",
"def color\n @color\n end",
"def color\n @color ||= color_scope.first\n end",
"def background_color\n return @peer.background_color\n end",
"def color\n @color ||= COLORS[label.length%COLORS.length].to_sym\n end",
"def chco\n (foreground || \"FFFFFF\") + \",\" + super\n end",
"def color(text)\n \"\\e[31m#{text}\\e[0m\"\n end",
"def colorize_log(msg)\n ACTIONS.each { |a| msg = color(msg, a[:color]) if msg.downcase.include?(a[:match]) }\n return msg\n end",
"def color\n @color || $def_fg_color\n end",
"def to_color_string\n ::PrintMembers::ColorString.new self\n end",
"def status_color\n if skipped?\n :yellow\n elsif error?\n :red\n else\n :green\n end\n end",
"def color_text\n @attributes[:color_text]\n end",
"def to_color color\n \"\\x1b[#{COLOR_CODE[color]}m#{to_s}\\x1b[m\"\n end",
"def color_class\n if waiting_confirmation?\n return \"warning\"\n elsif confirmed?\n return \"success\"\n else\n return \"danger\"\n end\n end",
"def output_color(text, color=text.to_i)\r\n # Color matches: 1 - Black; 2 - White; 3 - Red; 4 - Yellow; 5 - Green; 6 - Blue; 7 - Gold\r\n colors = { 1 => 30, 2 => 36, 3 => 31, 4 => 33, 5 => 35, 6 => 34, 7 => 220 }\r\n # \\e[47m Is for the grey foreground \\e[{color} is for picking the color and \\e[0m is for resetting the terminal.\r\n \"\\e[1m\\e[47m\\e[#{colors[color]}m#{text}\\e[0m\\e[22m\"\r\n end",
"def html_out(msg, color_name=\"black\")\n\t\t\trgb = Color::RGB::by_name color_name\n\t\t\tputs \"<span style='color:#{rgb.css_rgb};'>#{msg}</span>\"\n\t\tend",
"def knockout_color\n return Color.new(255, 64, 0)\n end",
"def font_color()\n validate_worksheet\n if @workbook.fonts[font_id()][:font][:color].nil?\n '000000' #black\n else\n @workbook.fonts[font_id()][:font][:color][:attributes][:rgb]\n end\n end",
"def colors\n @colors\n end",
"def red(msg)\n \"\\033[31m#{msg}\\033[39m\"\nend",
"def red\n colorize(31)\n end",
"def color\n @color;\n end",
"def stream_colour\n return interface.colour if name\n\n default[:colour]\n end",
"def display_color\n if @deleted\n return '#FF0000' # Red\n elsif !@enabled\n return '#AAAAAA' # Gray\n end\n \n '#000000'\n end",
"def to_s\n @color\n end",
"def system_color\n return Color.new(255,255,0)\n end",
"def puts_color( msg, color=nil )\n color_set( color ); puts msg; color_end\n end",
"def text_colors\n @colors = {\n red: 31,\n yellow: 33,\n green: 32\n }\n end",
"def color_codes\n {\n info: '#63C5DC',\n warning: 'warning',\n success: 'good',\n fatal: 'danger'\n }\n end",
"def colors() = @colors ||= %i[blue green purple magenta cyan yellow red]",
"def green\n colorize(32)\n end",
"def crisis_color\n return text_color(17)\n end",
"def message_types\n {\n create: [:light_cyan, :cyan],\n store: [:light_cyan, :cyan],\n update: [:light_cyan, :cyan],\n reset: [:light_cyan, :cyan],\n\n event: [:light_magenta, :magenta],\n\n timer: [:light_blue, :blue],\n\n info: [:white, :light_grey],\n test: [:white, :light_grey],\n debug: [:white, :light_grey],\n\n input: [:light_yellow, :yellow],\n output: [:light_green, :green],\n\n error: [:light_red, :red],\n\n config: [:light_blue, :blue],\n dsl: [:light_blue, :blue],\n editor: [:light_blue, :blue],\n drb: [:light_blue, :blue],\n }\n end",
"def get_user_balance_color(user)\n if user.balance.positive?\n \"#257942\"\n else\n \"#cc0f35\"\n end\n end",
"def yellow\n colorize(33)\n end",
"def hex_color\n return @hex_color\n end",
"def color(text, color)\n if COLORS[color]\n \"#{start_color color}#{text}#{reset_color}\"\n end\n end",
"def to_c\n\t\t\tif color == \"white\"\n\t\t\t\t\"\\u26aa\"\n\t\t\telsif color == \"red\"\n\t\t\t\t\"\\u26d4\"\n\t\t\telsif color == \"black\"\n\t\t\t\t\"\\u26ab\"\n\t\t\tend\n\t\tend",
"def colored_prompt\n return (Readline::VERSION !~ /EditLine/) && Pry.color if @colored_prompt.nil?\n\n @colored_prompt\n end",
"def colored_string\n color(to_bold_s)\n end",
"def status_color(accepted)\n if accepted == 0\n return \"style=\\\"color:red;\\\"\"\n elsif accepted == 1\n return \"style=\\\"color:gray;\\\"\"\n elsif accepted == 2\n return \"style=\\\"color:black;\\\"\"\n else\n return \"style=\\\"color:red;\\\"\"\n end\n end",
"def color\n @data['color']\n end",
"def notification_color(notification)\n return 'bg-post-it-blue' if notification.generic_announcement?\n return 'bg-post-it-red' if notification.announcement?\n return 'bg-post-it-orange' if notification.course? || notification.lecture?\n 'bg-post-it-yellow'\n end",
"def colorize(color, text)\n \"\\e[#{color}m#{text}\\e[0m\"\n end",
"def color\n filter << 'Color:Color'\n self\n end",
"def get_color(key)\n if key.is_a? String\n color = key\n elsif Wirb::COLORS.key?(key)\n color = Wirb::COLORS[key]\n end\n\n color ? \"\\033[#{ color }m\" : ''\n end",
"def error_color(text)\r\n \"<font color=red>#{text}</font>\"\r\n end",
"def mesaje_select(message)\n @mensajes.each do |e|\n if message.text == e.text\n e.color = @font_selection\n else\n e.color = @font_color\n end\n \n end\n end",
"def purple\n colorize(35)\n end",
"def color_id\n object.calendar.get_color(user_context.id)\n end",
"def colors\n return\n end",
"def color_map\n {\n 'high_risk_ice_check_in' => '#800080',\n 'friend_in_detention' => '#e83737',\n }\n end",
"def color_name\n COLOR[self.color.to_s]\n end",
"def color; end",
"def color; end",
"def color; end",
"def generate_color(status)\n if status == :completed\n :green\n elsif status == :failed\n :red\n else\n :yellow\n end\n end",
"def colorize_nick(gamer)\n if gamer[:premium?]\n case gamer.role\n when 2\n Format(:green, gamer.irc_nick)\n else\n Format(:yellow, gamer.irc_nick)\n end\n else\n gamer.irc_nick\n end\n end",
"def red\n colorize \"\\033[31m\"\n end",
"def font_color(color=nil)\n cur_page.font_color(color)\n end",
"def color(text, color_code)\n ::Guard::UI.send(:color_enabled?) ? \"\\e[0#{ color_code }m#{ text }\\e[0m\" : text\n end",
"def blue = \"\\e[36m#{self}\\e[0m\"",
"def colors\n @colors ||= parse_colors(color_properties)\n end",
"def to_color_log\n @lines.map.with_index do |val, i|\n case val[0][:status] \n when \" \"\n \"\\033[90m#{i} #{val[0][:status]} #{val[0][:string]}\\033[0m\"\n when \"+\"\n \"\\033[32m#{i} #{val[0][:status]} #{val[0][:string]}\\033[0m\"\n when \"-\"\n \"\\033[31m#{i} #{val[0][:status]} #{val[0][:string]}\\033[0m\"\n when \"*\"\n \"\\033[36m#{i} #{val[0][:status]} #{val[0][:string]}\\033[0m\"\n end\n end.join(\"\\n\") + \"\\n\"\n end",
"def severity_color(level)\n case level\n when \"DEBUG\"\n \"\\033[0;34;40m[DEBUG]\\033[0m\" # blue\n when \"INFO\"\n \"\\033[1;37;40m[INFO]\\033[0m\" # bold white\n when \"WARN\"\n \"\\033[1;33;40m[WARN]\\033[0m\" # bold yellow\n when \"ERROR\"\n \"\\033[1;31;40m[ERROR]\\033[0m\" # bold red\n when \"FATAL\"\n \"\\033[7;31;40m[FATAL]\\033[0m\" # bold black, red bg\n else\n \"[#{level} # none\"\n end\n end",
"def tutu_color\n\t @tutu_color\n\tend",
"def colors\n color_codes.keys\n end",
"def color_unless_remote(msg, color)\n if Origen.running_remotely?\n msg\n else\n msg.send(color)\n end\n end",
"def color=(value)\n @color = value\n end",
"def color=(value)\n @color = value\n end",
"def color\n case news_type\n when 'critical', 'love', 'angry' then 'red'\n when 'info' then 'blue'\n when 'warning' then 'orange'\n when 'success' then 'green'\n when 'disconcert' then 'purple'\n when 'tech' then '#555555'\n when 'premium' then '#FFCC00'\n else\n 'primary'\n end\n end",
"def color_style(task)\n color_property = session[:colors].to_i\n\n if color_property > 0\n property = current_user.company.properties.detect { |p| p.id == color_property }\n else \n property = current_user.company.properties.detect { |p| p.default_color }\n end\n\n value = task.property_value(property)\n if value\n return \"border-left: 4px solid #{ value.color }; background: none;\"\n end\n end",
"def print_status(msg, color)\n cprint RESET + BOLD\n cprint WHITE + \"[ \"\n cprint \"#{ msg } \", color\n cprint WHITE + \"] \" + RESET\n end",
"def print_status(msg, color)\n cprint RESET + BOLD\n cprint WHITE + \"[ \"\n cprint \"#{ msg } \", color\n cprint WHITE + \"] \" + RESET\n end",
"def color\n @users_from_history=User.all\n end",
"def normal_color\n #return Color.new(255,255,255)\n end",
"def invalid_color_msg(_clr)\n ''\n end",
"def invalid_color_msg(_clr)\n ''\n end",
"def yellow\n colorize \"\\033[33m\"\n end",
"def colors; end",
"def colorize(text, status = :normal)\n case status\n when :success\n text.green\n when :error\n text.red\n when :warning\n text.yellow\n when :neutral\n text.blue\n else\n text.white\n end\n end",
"def start_color color\n \"\\e[#{COLORS[color]}m\"\n end"
] |
[
"0.6822189",
"0.6671622",
"0.6671622",
"0.6510276",
"0.64185995",
"0.64103967",
"0.6400676",
"0.6391661",
"0.6387521",
"0.63467145",
"0.6305448",
"0.62759256",
"0.62428457",
"0.61948776",
"0.6142574",
"0.6139737",
"0.61388814",
"0.6075754",
"0.60551226",
"0.60551226",
"0.60398203",
"0.603945",
"0.60163784",
"0.60038817",
"0.60023385",
"0.5972767",
"0.5969862",
"0.5956217",
"0.5955581",
"0.59444934",
"0.5937621",
"0.5936004",
"0.59308636",
"0.59268564",
"0.5920187",
"0.5919703",
"0.58973616",
"0.589566",
"0.5881384",
"0.5857489",
"0.5857041",
"0.5856634",
"0.5849527",
"0.5845718",
"0.58328587",
"0.58192647",
"0.5814428",
"0.5796425",
"0.57788736",
"0.5769404",
"0.57422924",
"0.5741146",
"0.5739468",
"0.5721647",
"0.57145774",
"0.56909513",
"0.56829953",
"0.56829774",
"0.5676242",
"0.5648657",
"0.5646634",
"0.5645293",
"0.5643795",
"0.5639026",
"0.562746",
"0.56178117",
"0.56158453",
"0.56114084",
"0.56060874",
"0.5588297",
"0.5573238",
"0.5562586",
"0.5562586",
"0.5562586",
"0.5556529",
"0.5555035",
"0.5554668",
"0.55406123",
"0.553862",
"0.5535776",
"0.5535621",
"0.55335534",
"0.5531483",
"0.5525309",
"0.55230635",
"0.5523006",
"0.5515659",
"0.55151373",
"0.55149364",
"0.5502888",
"0.5495298",
"0.5495298",
"0.5493928",
"0.5493772",
"0.5482298",
"0.5482298",
"0.5481875",
"0.5478228",
"0.5477415",
"0.54743207"
] |
0.6738438
|
1
|
Returns a JSON hash describing the session info for this user.
|
def presence_info
{
name: @user.name,
name_color: @name_color,
av_nonce: @av_nonce
}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def session_hash(user)\n {\n username: user.username,\n authentication_token: user.authentication_token\n }\n end",
"def to_session_hash\n {:id => self.id, :name => self.name, :email => self.email, :language => self.language}\n end",
"def session_to_s\n return '' if @session.nil?\n\n s = '{'\n [ 'auth', 'seed', 'ip', 'user', 'session_expires' ].each do |k|\n s += \"'#{k}':'#{@session[k]}', \"\n end\n s += '}'\n return s\n end",
"def user_information\n { \"username\": @user.username, \"email\": @user.email, \"id\": @user.id }\n end",
"def info()\n get(:session, {:method => \"user.getInfo\"})\n end",
"def user_info\n {\n 'nickname' => user_hash['NickName'],\n 'name' => user_hash['NickName']\n }\n end",
"def user_info\n @current_user ||= User.find(session[:user_id]) if session[:user_id]\n\n respond_to do |format|\n name = @current_user.name\n username = @current_user.username\n format.json {\n render json: {\n :name => name,\n :username => username,\n }.to_json, status: 200\n }\n end\n end",
"def user_info\n auth_hash['user_info']\n end",
"def user\n hash = {\n provider: 'josh_id',\n id: current_user.id.to_s,\n info: {\n email: current_user.email,\n username: current_user.username,\n #first_name: current_user.first_name,\n }\n }\n\n render json: hash.to_json\n end",
"def get_session\n session = Session.create!(key: Random.rand(0xFFFFFFFF).to_s)\n render json: { id: session.id, key: session.key }\n end",
"def session\n raw_session[\"warden.user.#{scope}.session\"] ||= {}\n end",
"def profile\n _uuid = uuid.gsub(/-/, '')\n url = \"https://sessionserver.mojang.com/session/minecraft/profile/#{_uuid}\"\n response = Net::HTTP.get_response(URI.parse(url))\n json = JSON.parse(response.body)\n end",
"def get_session\n if session[:user_id].present? && session[:user_name].present?\n @result = {flag:true , session_id: session[:user_id] , :user_name=> session[:user_name]}\n render :json=>@result\n else \n @result = {flag:false}\n render :json=>@result\n end\n end",
"def session_report\n ts = Time.now\n now = ts.to_i\n session_info = Maglev::System.current_session_ids.map do |id|\n sess_desc = Maglev::System.description_of_session id\n sess_desc[0] = sess_desc[0].instance_variable_get(:@_st_userId) # UserProfile\n sess_desc[3] = '' if sess_desc[3] == 0 # Primitive?\n sess_desc[4] = format_secs(now - sess_desc[4]) # View Age\n sess_desc[6] = ['none', 'out', 'in'][sess_desc[6] + 1] # Transaction\n sess_desc[13] = format_secs(now - sess_desc[13]) # Quiet\n sess_desc[14] = format_secs(now - sess_desc[14]) # Age\n sess_desc\n # sess_cache_slot = Maglev::System.cache_slot_for_sessionid id\n end\n session_info\n end",
"def facebook_session_key\n @json['sessionKey']\n end",
"def get_connected_user_info\n session[:sos_note_usr_info]\n end",
"def get_cur_user\n @user = nil\n if is_logged_in session\n @user = User.find_by_sunet(session[:user_hash][\"username\"])\n end\n render json: @user\n end",
"def get_cur_user\n @user = nil\n if is_logged_in session\n @user = User.find_by_sunet(session[:user_hash][\"username\"])\n end\n render json: @user\n end",
"def show\n @session = Sso::Session.find(sso_session_id)\n render json: @session, serializer: Sso::SessionSerializer\n end",
"def user_hash\n response_hash.key?(:user) ? response_hash[:user] : {}\n end",
"def show\n begin\n if m = params[:id].match(/([^\\.]+)/)\n uid = m.captures.first\n else\n uid = params[:id]\n end\n sso_session = params[:session]\n\n # Check if session is valid\n @valid_session = (!uid.blank? && !sso_session.blank? && User.where(uid:uid,sso_session:sso_session).count > 0)\n\n # Build response\n response_hash = {\n valid: @valid_session,\n recheck: 3.minutes.from_now.utc\n }\n\n logger.info(\"INSPECT: session_hash => #{response_hash}\")\n\n render json: response_hash\n rescue Exception => e\n logger.error(e)\n raise e\n end\n end",
"def get_info\n @info ||= @instance.client.getSessionInfo(sessionID: @id)\n end",
"def _data\n @session[SESSION_KEY] || {}\n end",
"def inspect\n\t\t\"#<Session:#{self.type} #{self.tunnel_peer} #{self.info ? \"\\\"#{self.info.to_s}\\\"\" : nil}>\"\n\tend",
"def serialize_for_session\n @serialized_data ||= serialize_object_for_session\n end",
"def user_info\n response = from_server \"api/user.json\"\n response.data\n end",
"def get_user_info\n response = HTTParty.get(\n \"https://api.github.com/user\",\n :headers => {\n \"Authorization\" => \"Bearer #{session[:access_token]}\",\n \"User-Agent\" => \"OAuth Test App\"\n }\n )\n session[:email] = response[\"email\"]\n session[:name] = response[\"name\"]\n session[:user_image] = response[\"avatar_url\"]\n session[:provider] = \"GitHub\"\n end",
"def sso_logging_info\n { user_uuid: @current_user&.uuid,\n sso_cookie_contents: sso_cookie_content,\n request_host: request.host }\n end",
"def sign_in_json\n {\n id: pretty_id,\n email: email,\n firstname: firstname,\n lastname: lastname,\n }\n end",
"def user_hash\n @user_hash ||= MultiJson.decode(@access_token.get('https://api.trademe.co.nz/v1/MyTradeMe/Summary.json').body)\n end",
"def user_data\n {\n user_id: @user.id,\n email: @user.email\n }\n end",
"def cached_session_data\n Authentication::RedisStore.instance.json_get(auth_token)\n end",
"def as_json_type20\n as_json({\n only: [\n :id,\n :key,\n ],\n methods: [\n :session_lock_token,\n ],\n })\n end",
"def to_json\n attrs = attributes\n if attrs['user'] && attrs['user']['id'] == '$current'\n attrs.delete 'user'\n end\n attrs.to_json\n end",
"def get_user_session_data(opts = {})\n data, _status_code, _headers = get_user_session_data_with_http_info(opts)\n data\n end",
"def as_json(options={})\n hash = super(options)\n hash['user']['password'] = ''\n hash\n end",
"def session_serializer\n @session_serializer ||= Watchman::SessionSerializer.new(@env)\n end",
"def get_session\n begin\n if session[:user_id].present? && session[:user_name].present? && current_user.present?\n unless session[:comp_id].present?\n @result = {flag:true , session_id: session[:user_id] , :user_name=> session[:user_name]} \n else\n @result = {flag:true , session_id: session[:user_id] , :user_name=> session[:user_name] , :comp_id=> session[:comp_id]}\n end \n render :json=>@result\n else \n reset_session \n @result = {flag:false}\n render :json=>@result\n end \n rescue Exception=> e\n reset_session \n @result = {flag:false}\n render :json=>@result\n end\n \n end",
"def user_details\n\t\t@user_data = Hash.new\n\t\t@user_data[\"first_name\"] = @first_name\n\t\t@user_data[\"username\"] = @username\n\t\t@user_data[\"password\"] = @password\n\t\t@user_data[\"balance\"] = @balance\n\tend",
"def user_hash\n @user_hash ||= MultiJson.decode(@access_token.get('/services/api/json/1.2.2/?method=smugmug.auth.checkAccessToken').body)['Auth']['User']\n end",
"def session_get\n nessus_rest_get(\"session\")\n end",
"def user_info\n @user_info ||= raw_info.nil? ? {} : raw_info\n end",
"def user_info\n @user_info ||= raw_info.nil? ? {} : raw_info\n end",
"def user_session\n\t\t@user_session ||= UserSession.new(session)\n\tend",
"def serialize_into_session(record)\n [record.serializable_hash.stringify_keys, nil]\n end",
"def user_data\n {:username => self.username,\n :pic_url => self.user_pic,\n :profile_url => self.profile_url\n }\n end",
"def user_data\n {\n id: @user.id,\n email: @user.email,\n user_token_sale_state: @user_token_sale_state,\n bt_name: @user.bt_name.to_s\n }\n end",
"def user\n {user_id: self.object.user.id,\n user_name: self.object.user.name\n }\n end",
"def valid_session\n {\n # good: \"user_id\"=> @user.id\n \"user_id\"=> user.id \n }\n end",
"def getUserDetails\n\t\tuser = java.util.HashMap.new()\n\t\t# user name\n\t\tuser.put(KEY_NAME, @pref.getString(KEY_NAME, nil))\n\t\t\n\t\t# user email id\n\t\tuser.put(KEY_EMAIL, @pref.getString(KEY_EMAIL, nil))\n\t\t\n\t\t# return user\n\t\treturn user;\n\tend",
"def info\n {\n email: username\n }\n end",
"def session_user\n decoded_hash = decoded_token\n if decoded_hash && !decoded_hash.empty?\n user_id = decoded_hash[0]['user_id']\n @user = User.find_by(id: user_id)\n else\n nil\n end\n end",
"def user_session_params\n params[:user_session]\n end",
"def save_to_session\n\t\t\t\t\tresult = {}\n\t\t\t\t\t\n\t\t\t\t\tif !self.user_id.blank? && !self.role_ref.blank?\n\t\t\t\t\t\tresult[\"user_id\"] = self.user_id\n\t\t\t\t\t\tresult[\"role_ref\"] = self.role_ref\n\t\t\t\t\t\tresult[\"changed\"] = true\n\t\t\t\t\t\n\t\t\t\t\telsif !self.user_id.blank?\n\t\t\t\t\t\tresult[\"user_id\"] = self.user_id\n\t\t\t\t\t\tself.role_ref = self.user.role\n\t\t\t\t\t\tresult[\"role_ref\"] = self.role_ref\n\t\t\t\t\t\tresult[\"changed\"] = true\n\n\t\t\t\t\tend\n\n\t\t\t\t\treturn result\n\t\t\t\tend",
"def get_user_data\n user_data = nil\n \n if cookies.has_key?(:user_data) && cookies[:user_data].to_s != ''\n user_data = string_to_hash(cookies[:user_data])\n end\n user_data\n end",
"def sign_in_json\n {\n id: id.to_s,\n email: email,\n firstname: firstname,\n lastname: lastname,\n schools: schools.map{|s| {id: s.id.to_s, name: s.name}},\n admin: shapter_admin,\n confirmed: confirmed?,\n sign_in_count: sign_in_count,\n }.to_json\n end",
"def service_response_data\n {\n user: @user.get_hash\n }\n end",
"def sso_cookie_content\n return nil if @current_user.blank?\n\n {\n 'patientIcn' => (@current_user.mhv_icn || @current_user.icn),\n 'mhvCorrelationId' => @current_user.mhv_correlation_id,\n 'signIn' => @current_user.identity.sign_in.deep_transform_keys { |key| key.to_s.camelize(:lower) },\n 'credential_used' => sso_cookie_sign_credential_used,\n 'expirationTime' => @session_object.ttl_in_time.iso8601(0)\n }\n end",
"def inspect\n \"#<Mongo::Session:0x#{object_id} session_id=#{session_id} options=#{@options}>\"\n end",
"def set_session user\n session[:user_id] = user.id\n session[:user_fullname] = user.fullname\n session[:user_email] = user.email\n session[:user_access] = user.access\n session[:company_id] = user.company_id\n end",
"def user_info\n {\n 'uid' => user_hash['feed']['author'][0]['email']['$t'],\n 'nickname' => user_hash['feed']['author'][0]['name']['$t'],\n }\n end",
"def user_info\n @user_info ||= raw_info\n end",
"def to_s\n \"Version => #{@version}, SessionObj => #{@session}, Response => #{@response}\"\n end",
"def credentials\n session = Session.find_by(id: params[:id])\n if params[:userId] and user = User.find_by(id: params[:userId])\n user_id = user.id\n username = user.username\n if session_user = SessionUser.find_by(user_id: user.id, session_id: params[:id])\n role = session_user.role.to_sym\n else\n role = :publisher\n end\n else\n user_id = nil \n username = \"unknown\"\n role = :subscriber\n end\n token = @@opentok.generate_token(session.session_id, {role: role, data: user.id})\n result = {\n OTApiKey: ENV['OPENTOK_API_KEY'],\n OTSessionId: session.session_id,\n OTToken: token,\n userId: user_id,\n username: username,\n role: role\n }\n render json: result\n end",
"def user_info\n {\n 'uid' => user_hash['feed']['author'][0]['email']['$t'],\n 'nickname' => user_hash['feed']['author'][0]['name']['$t']\n }\n end",
"def user_session\n @user_session ||= UserSession.new(session, cookies)\n end",
"def session_enduser\n session[:enduser] = params[:enduser]\n\n respond_to do |format|\n format.json { head :ok }\n end\n end",
"def info\n oauth_response = access_token.get \"/api/v1/users/current.json\"\n JSON.parse(oauth_response.body)\n end",
"def inspect\n \"#<Mongo::Session::ServerSession:0x#{object_id} session_id=#{session_id} last_use=#{@last_use}>\"\n end",
"def get_user_info()\n return_map = nil\n if session[:google_unique] != nil && user_credentials.access_token != nil\n return_map = {}\n return_map['email'] = session[:googleemail]\n return_map['sub'] = session[:google_unique]\n return_map['useralias'] = session[:useralias]\n end\n return return_map\nend",
"def get_session(options = {})\n resp = @connection.post do |req|\n req.headers = { :Accept => 'application/json'}\n req.url 'v1/sessions'\n req.body = options.to_json\n end\n check_response_for_errors resp.body\n end",
"def session_tokens\n @data[:session_tokens]\n end",
"def session\n @session ||= options[:session] || {} \n end",
"def sessions\n @@session_set ||= ActiveRecord::SessionStore::Session.all.select{|s| s.data.has_key?(\"user_credentials_id\")}\n @@session_set.select{|s| s.data[\"user_credentials_id\"] == self.id}\n end",
"def show\n {\n id: @current_user.id,\n email: @current_user.email,\n access_token: @current_user.access_token\n }\n end",
"def current_user\n return nil unless valid_session?\n\n OpenStruct.new(\n id: session['uid'],\n email: session['email']\n )\n end",
"def marshal(session)\n data = [ Marshal.dump(session) ].pack('m').chop\n \"#{data}--#{generate_digest(data)}\"\n end",
"def to_session(project_id)\n booking = db_api.get_booking(project_id,\n booking_id,\n Config::Global.studio_id)\n booking = JSON.parse(booking)\n\n { session: {\n project_id: project_id,\n studio: Config::Global.studio_id,\n date: booking['date'],\n start_time: booking['start_time'],\n end_time: booking['end_time']\n } }\n end",
"def session\n @current_user = User.find_by_access_token(params[:access_token])\n \n # Fetch content for current user\n # find_friends_for_facebook_id(@current_user.facebook_id, since = nil)\n \n # return new friends\n # We want to send the entire friendslist hash of id, name to the client\n # friend_array = Friendship.find(:all, :select=>\"friend_id, friend_name\", :conditions=>\"user_id = #{@current_user.id}\").map {|f| {:friend_id=>f.friend_id.to_i, :friend_name=>f.friend_name}}\n # friend_id_array = friend_array.map do |f| f[:friend_id] end\n # \n # # The response should include the current user ID and name for the client to cache\n # session_response_hash = {\n # :access_token => @current_user.access_token,\n # :facebook_id => @current_user.facebook_id,\n # :name => @current_user.name,\n # :friends => friend_array\n # }\n \n session_response_hash = {\n :access_token => @current_user.access_token\n }\n\n respond_to do |format|\n format.xml { render :xml => session_response_hash.to_xml }\n format.json { render :json => session_response_hash.to_json }\n end\n end",
"def getUser\n render json: @current_user, status: 200\n end",
"def to_hash\n {\n provider: 'maestrano',\n uid: self.to_uid,\n info: {\n email: self.to_email,\n first_name: self.first_name,\n last_name: self.last_name,\n country: self.country,\n company_name: self.company_name,\n },\n extra: {\n uid: self.uid,\n virtual_uid: self.virtual_uid,\n real_email: self.email,\n virtual_email: self.virtual_email,\n group: {\n uid: self.group_uid,\n name: self.group_name,\n role: self.group_role,\n },\n session: {\n uid: self.uid,\n token: self.sso_session,\n recheck: self.sso_session_recheck,\n group_uid: self.group_uid\n },\n }\n }\n end",
"def to_datadog_hash\n {\n \"usr.id\" => id,\n \"usr.access_level\" => access_level,\n \"usr.sync_approval_status\" => sync_approval_status\n }\n end",
"def user_session\n @user_session ||= UserSession.find\n end",
"def session_info(m)\r\n s = Justbot::Session.for(m)\r\n if s.nil?\r\n m.reply(\"You don't currently have a session.\")\r\n return\r\n end\r\n\r\n reply_in_pm(m) do |r|\r\n r << \"You have a session!\"\r\n r << \" mask: #{s.mask}\"\r\n r << \" expires: #{s.expiration}\"\r\n r << \" is authed: #{s.authed?}\"\r\n end\r\n end",
"def session\n env[\"rack.session\"] || {}\n end",
"def valid_session\n {user_id: @user.id}\n end",
"def session\r\n @session ||= {}\r\n end",
"def to_s\n {\n fullname: fullname,\n address: address,\n dob: dob,\n email: email,\n username: username\n }.to_json\n end",
"def sessions\n @sessions.each_key.to_a\n end",
"def show\n @user = User.find(params[:id])\n @sessionname = session[:current_user_id]\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @user }\n end\n end",
"def show\n @user = User.find(params[:id])\n @sessionname = session[:current_user_id]\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @user }\n end\n end",
"def to_hash\n hsh = {\n id: id,\n status: status.to_sym,\n connect: running? ? connect.to_h : nil,\n time: info.wallclock_time.to_i / 60 # only update every minute\n }\n Digest::SHA1.hexdigest(hsh.to_json)\n end",
"def sessions\n @sessions\n end",
"def get_session\n @authenticator.get_session\n end",
"def user_from_session\n user = user_from_claims\n return user unless session[:auth0_json]\n raw = JSON.parse(session[:auth0_json] || '{}').with_indifferent_access.fetch(:extra, {}).fetch(:raw_info, {})\n user.email = raw.fetch(:email, user.email)\n user.picture = raw.fetch(:picture, user.picture)\n user.user_metadata = raw.fetch(:user_metadata, user.user_metadata)\n user\n end",
"def build_session\n # If it's empty assume user doesn't need session attributes.\n @session_attributes = Hash.new if @session_attributes.nil?\n @session = { :sessionAttributes => @session_attributes }\n @session\n end",
"def to_session_value; end",
"def user_info\n @user_info ||= raw_info.nil? ? {} : raw_info['query']['results'][\"profile\"]\n end",
"def C_GetSessionInfo()\n @pk.C_GetSessionInfo(@sess)\n end",
"def to_json\n @users.map { |item|\n item[:user].to_hash.merge({ :rooms => item[:connections].map { |conn|\n conn.room.identifier\n } })\n }.to_json\n end",
"def user_data\n User.user_data login\n end"
] |
[
"0.7872431",
"0.73587406",
"0.6997041",
"0.6704282",
"0.6584308",
"0.65706366",
"0.65043086",
"0.64443815",
"0.64112914",
"0.64012635",
"0.6400366",
"0.63847876",
"0.6377968",
"0.6312867",
"0.63016415",
"0.6296805",
"0.62919784",
"0.62919784",
"0.6266916",
"0.6250338",
"0.62444305",
"0.62433696",
"0.6212992",
"0.6184933",
"0.6172884",
"0.6166733",
"0.6149831",
"0.61397845",
"0.6128875",
"0.61091006",
"0.60786366",
"0.6077915",
"0.60578096",
"0.6054425",
"0.60489494",
"0.60159117",
"0.60033333",
"0.59950346",
"0.5986945",
"0.59848034",
"0.5984112",
"0.5955634",
"0.5955634",
"0.59468865",
"0.59378976",
"0.59207904",
"0.5920659",
"0.5919893",
"0.5918345",
"0.5907598",
"0.5904234",
"0.59009016",
"0.5900246",
"0.58950216",
"0.58948064",
"0.58892316",
"0.58874005",
"0.5877023",
"0.5877001",
"0.58747905",
"0.5862398",
"0.58552027",
"0.5844121",
"0.5843597",
"0.58431435",
"0.58243775",
"0.5809249",
"0.580431",
"0.5795103",
"0.5779877",
"0.5778805",
"0.57672817",
"0.57542306",
"0.5753084",
"0.5749007",
"0.5739763",
"0.5738126",
"0.573227",
"0.57272434",
"0.57231987",
"0.5716794",
"0.57153475",
"0.57148176",
"0.5709651",
"0.5706986",
"0.56978565",
"0.5696679",
"0.5695083",
"0.56885976",
"0.56876165",
"0.56876165",
"0.56851166",
"0.5682158",
"0.5681281",
"0.568113",
"0.56799835",
"0.56787074",
"0.5673312",
"0.56725776",
"0.56695116",
"0.5669112"
] |
0.0
|
-1
|
Transmits any events that the client might not know about.
|
def sync_events
events = @last_event_id ? @room.events_after(@last_event_id) :
@room.recent_events(512)
return if events.empty?
respond_recent_events events
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def send_events; end",
"def send_event( data )\n\t\tuntil data.empty?\n\t\t\tbytes = self.socket.sendmsg_nonblock( data, 0, exception: false )\n\n\t\t\tif bytes == :wait_writable\n\t\t\t\tIO.select( nil, [self.socket], nil )\n\t\t\telse\n\t\t\t\tself.log.debug \"Sent: %p\" % [ data[0, bytes] ]\n\t\t\t\tdata[ 0, bytes ] = ''\n\t\t\tend\n\t\tend\n\tend",
"def transmit(id, params)\n need_event_handling = false\n if event = params[:event]\n observers = @@observers.has_key?(@path) ? @@observers[@path].dup : nil\n observers.each do |name, obs|\n begin obs.__send__(event, params) if obs.respond_to?(event)\n rescue Exception; Channel.ignore(@path, name) end\n end if observers\n need_event_handling = observers.nil? || observers.empty?\n end\n if event.nil? || need_event_handling\n if params[:except]\n exception = [params[:except]].flatten\n @waiters.each do |signature, server|\n next if exception.include?(server.uid)\n server.commit if server.respond(id, params)\n end\n else\n @waiters.each do |signature, server|\n server.commit if server.respond(id, params)\n end\n end\n end\n end",
"def send(evt)\n @client.send_event(evt) if @client\n end",
"def send_all(event, data)\n\t\tEM.next_tick {\n\t\t\t@sockets.each do |s|\n\t\t\t\ts.send(event, data) \n\t\t\tend\n\t\t}\n\tend",
"def send(evt)\n @client.send(evt) if @client\n end",
"def send\n # discard if sampling rate says so\n if @libhoney.should_drop(self.sample_rate)\n @libhoney.send_dropped_response(self, \"event dropped due to sampling\")\n return\n end\n\n self.send_presampled()\n end",
"def send_event( data )\n\n\t\tuntil data.empty?\n\t\t\tbytes = self.socket.send( data, 0, self.multicast_address, self.port )\n\n\t\t\tself.log.debug \"Sent: %p\" % [ data[0, bytes] ]\n\t\t\tdata[ 0, bytes ] = ''\n\t\tend\n\tend",
"def send_events=(_arg0); end",
"def send_others(event, data)\n\t\tEM.next_tick {\n\t\t\t@sockets.each do |s|\n\t\t\t\ts.send(event, data) if s != self\n\t\t\tend\n\t\t}\n\tend",
"def send\n # discard if sampling rate says so\n if @libhoney.should_drop(sample_rate)\n @libhoney.send_dropped_response(self, 'event dropped due to sampling')\n return\n end\n\n send_presampled\n end",
"def broadcast(event, data)\n #only keep the last 5000 Events\n if @history.size >= 6000\n @history.slice!(0, @history.size - 1000)\n end\n @lastEventId += 1\n @history << {id: @lastEventId, event: event, data: data}\n info \"Sending Event: #{event} Data: #{data} to #{@connections.count} Clients\"\n @connections.each do |socket|\n async.send_sse(socket, data, event, @lastEventId)\n end\n true\n end",
"def write( event )\n nil\n end",
"def dispatch_incoming_packets(raise_disconnect_errors: T.unsafe(nil)); end",
"def broadcast\n end",
"def handle_writable_io_event( event )\n\t\tif message = self.send_queue.shift\n\t\t\tmessage.send_to( self.socket )\n\t\telse\n\t\t\tself.reactor.disable_events( self.socket, :write )\n\t\tend\n\tend",
"def index\n last_event_id = 0\n key = params[:key]\n response.headers['Content-Type'] = 'text/event-stream'\n puts \"subscribing to #{key}\"\n begin\n sse = SSE.new(response.stream)\n ticker = Thread.new do\n sse.write 0, event: 'ack'\n sleep 5\n end\n\n r = Redis.new\n streamer = Thread.new do\n r.subscribe(key) do |on|\n on.message do |channel, message|\n response.stream.write(message)\n end\n end\n end\n\n ticker.join\n streamer.join\n rescue IOError\n puts \"ioerror:: #{$!}\"\n ensure\n Thread.kill(ticker) if ticker\n Thread.kill(streamer) if streamer\n sse.close\n r.quite\n end\n end",
"def test_ignored_events\n\tpeer2peer do |remote|\n\t model = Tasks::Simple.new_submodel do\n\t\tevent :unknown, :command => true\n\t end\n\t remote.plan.add_mission(t1 = Tasks::Simple.new(:id => 1))\n\t remote.plan.add_mission(t2 = Tasks::Simple.new(:id => 2))\n\t remote.plan.add_mission(u = model.new(:id => 0))\n\n\t t1.signals(:start, u, :unknown)\n u.forward_to(:unknown, t2, :start)\n\n\t remote.singleton_class.class_eval do\n\t\tdefine_method(:remove_relations) do\n\t\t t1.event(:start).remove_signal u.event(:unknown)\n\t\t u.event(:unknown).remove_forwarding t2.event(:start)\n\t\tend\n\t end\n\tend\n\n\tu = subscribe_task(:id => 0)\n\tt1 = remote_task(:id => 1)\n\tt2 = remote_task(:id => 2)\n\n\tassert(remote_peer.connected?)\n\n\tremote.remove_relations\n\tprocess_events\n\tassert(remote_peer.connected?)\n end",
"def no_more_events!\n @ws.close\n end",
"def index\n @quacks = Quack.all\n # SSE expects the `text/event-stream` content type\n response.headers['Content-Type'] = 'text/event-stream'\n\n sse = Reloader::SSE.new(response.stream)\n begin\n loop do\n sse.write({ :time => Time.now })\n sleep 1\n end\n rescue IOError\n # When the client disconnects, we'll get an IOError on write\n ensure\n sse.close\n end\n end",
"def suppress_events\n self.events_suppressed = true\n yield\n self.events_suppressed = false\n end",
"def send_requests(evts)\n if evts.size < 1\n LOGGER.info(\"Skipping sending events since buffer is empty\")\n return\n end\n LOGGER.info(\"Attempting to send #{evts.size} request#{evts.size == 1 ? '' : 's'}\")\n\n evts.each do |event|\n event['stm'] = (Time.now.to_f * 1000).to_i.to_s # add the sent timestamp, overwrite if already exists\n end\n\n if @method == 'post'\n post_succeeded = false\n begin\n request = http_post(SelfDescribingJson.new(\n 'iglu:com.snowplowanalytics.snowplow/payload_data/jsonschema/1-0-4',\n evts\n ).to_json)\n post_succeeded = is_good_status_code(request.code)\n rescue StandardError => se\n LOGGER.warn(se)\n end\n if post_succeeded\n unless @on_success.nil?\n @on_success.call(evts.size)\n end\n else\n unless @on_failure.nil?\n @on_failure.call(0, evts)\n end\n end\n\n elsif @method == 'get'\n success_count = 0\n unsent_requests = []\n evts.each do |evt|\n get_succeeded = false\n begin\n request = http_get(evt)\n get_succeeded = is_good_status_code(request.code)\n rescue StandardError => se\n LOGGER.warn(se)\n end\n if get_succeeded\n success_count += 1\n else\n unsent_requests << evt\n end\n end\n if unsent_requests.size == 0\n unless @on_success.nil?\n @on_success.call(success_count)\n end\n else\n unless @on_failure.nil?\n @on_failure.call(success_count, unsent_requests)\n end\n end\n end\n\n nil\n end",
"def send_pending; end",
"def events tcpSock, action\n begin\n tcpSock.write \"Action: Events\\r\\n\"\n tcpSock.write \"EventMask: #{action}\\r\\n\\r\\n\"\n rescue => error\n log \"#{error}\"\n end\nend",
"def unsend!\n @_sended = false\n end",
"def to_wires_event; self; end",
"def safe_publish(event)\n if connection.status == :open\n exchange.publish(event.to_json, :routing_key => routing_key)\n else\n say \"Event not sent. Connection status is #{connection.status}: \" + \\\n \"#{event.to_json}\"\n end\n end",
"def handle_all_events\r\n @connection.set_generic_handler do |event|\r\n begin\r\n handle_event(event)\r\n rescue => exception\r\n $stderr.puts exception.inspect\r\n $stderr.puts exception.backtrace\r\n end\r\n end\r\n true\r\n end",
"def events\n response.headers['Content-Type'] = 'text/event-stream' # Starts a Redis event stream (thread)\n room_id = params[:room_id]\n sse = Streamer::SSE.new(response.stream) # Opens server sent event stream\n redis ||= Redis.new # If the user doesn't already have a thread open, creates a new redis thread\n # --- Adds all the subscription events for each room --- \n redis.subscribe([\"add_message_#{room_id}\", \"remove_message_#{room_id}\", \"heart\"]) do |on|\n on.message do |event, data|\n if event == \"add_message_#{room_id}\" # For the add song subscription\n sse.write(data, event: \"add_message_#{room_id}\")\n elsif event == \"remove_message_#{room_id}\"\n sse.write(data, event: \"remove_message_#{room_id}\")\n end\n end\n end\n # --- end ---\n rescue IOError\n # Client disconnected\n redis.quit\n sse.close\n response.stream.close\n ensure\n # When not being used, threads close\n redis.quit\n sse.close\n response.stream.close\n end",
"def event_incoming_clients_control(client, cmd, *args)\nend",
"def send_requests(events)\n if events.empty?\n logger.info('Skipping sending events since buffer is empty')\n return\n end\n\n logger.info(\"Attempting to send #{events.size} request#{events.size == 1 ? '' : 's'}\")\n\n events.each do |event|\n # add the sent timestamp, overwrite if already exists\n event['stm'] = Timestamp.create.to_s\n end\n\n if @method == 'post'\n send_requests_with_post(events)\n elsif @method == 'get'\n send_requests_with_get(events)\n end\n\n nil\n end",
"def emits_none\n @emittable = {}\n nil\n end",
"def event_incoming_client_control(client, peer, cmd, *args)\nend",
"def wait_all_sent\n verify_not_closed\n @clients.each do |pub|\n pub.wait_all_sent\n end\n end",
"def send_event\n raise 'send_event must be defined in the child class'\n end",
"def events\n response.headers['Content-Type'] = 'text/event-stream' # Starts a Redis event stream (thread)\n room_id = params[:room_id]\n sse = Streamer::SSE.new(response.stream) # Opens server sent event stream\n redis ||= Redis.new # If the user doesn't already have a thread open, creates a new redis thread\n # --- Adds all the subscription events for each room --- \n redis.subscribe([\"add_song_#{room_id}\", \"add_user_#{room_id}\", \"change_song_#{room_id}\", \"remove_user_#{room_id}\", \"like_or_dislike_#{room_id}\", \"add_message_#{room_id}\", \"heart\"]) do |on|\n on.message do |event, data|\n \tif event == \"add_song_#{room_id}\" # For the add song subscription\n \t\tsse.write(data, event: \"add_song_#{room_id}\")\n \telsif event == \"add_user_#{room_id}\" # For the add user subscription\n \tsse.write(data, event: \"add_user_#{room_id}\")\n elsif event == \"change_song_#{room_id}\" # For the change song subscription\n \tsse.write(data, event: \"change_song_#{room_id}\")\n elsif event == \"remove_user_#{room_id}\" # For the remove user subscription\n \tsse.write(data, event: \"remove_user_#{room_id}\")\n elsif event == \"like_or_dislike_#{room_id}\" # For the like/dislike subscription\n \tsse.write(data, event: \"like_or_dislike_#{room_id}\")\n elsif event == \"add_message_#{room_id}\" # For the add message subscription\n \tsse.write(data, event: \"add_message_#{room_id}\")\n elsif event == \"heart\" # For the heartbeat subscription\n \tsse.write(data, event: \"heart\")\n \tend\n end\n end\n # --- end ---\n rescue IOError\n # Client disconnected\n redis.quit\n sse.close\n response.stream.close\n ensure\n \t# When not being used, threads close\n redis.quit\n sse.close\n response.stream.close\n end",
"def write_events(events)\n @events += @before_write.call(events)\n end",
"def received\n end",
"def charge_events\n require_event_type('charge')\n head :no_content\n end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def events; end",
"def isolate_signals; end",
"def broadcast\n queued_data = JSON.generate(@send_queue.shift)\n @sockets.each do |socket|\n socket.send queued_data\n end\n end",
"def index\n @connection.request(:index).map { |e| Event.new(self, e) }\n end",
"def client_handler(client, all_clients)\n client.puts 'Welcome to server, stranger!'\n loop do\n msg = client.gets\n if msg.nil?\n puts 'Client disconnected'\n break\n end\n all_clients.each { |dest| send_msg(msg, dest) if dest != client }\n end\nend",
"def events\n end",
"def let_go\n # And now here comes the events\n octo.grab \"push\" do |events|\n events.each_pair do |path, evts|\n evts.select! {|evt| Time.parse(evt[\"created_at\"]).getlocal(\"+08:00\").within_deadline?}\n # Since the text length can be no longer than 65536, split it just in case\n count = (JSON.dump(evts).length / MSG_SIZE_LIMIT) + 1\n slice_size = evts.length / count\n evts.each_slice(slice_size) do |partial|\n obj = {\n \"path\" => path,\n \"evts\" => partial\n }\n\n @queue.send_message(JSON.dump(obj))\n end\n end\n end\n end",
"def parallel_common_events\n rm_extender_pc.select {|e| e && !e.for_battle?}\n end",
"def on_sendable(event)\n Qpid::Proton::Event.dispatch(@delegate, :on_sendable, event) if !@delegate.nil?\n end",
"def send_event(event, hint = nil)\n client.send_event(event, hint)\n end",
"def graceful\n @accepting = false\n @outbox.put HaltTransmission\n \n # When the outbox-loop encounters the HaltTransmission,\n # it will break itself and close the connection.\n # See also the end of the #talk method.\n \n end",
"def on_bytes(ev)\n\t\tclient = @clients[ev.src_addr]\n\t\t# client can only be 0 if it's a connect packet\n\t\tpost_event bytes_to_event(client,ev.bytes)\n\tend",
"def send!\n @_sended = true\n self\n end",
"def notify\n socket.write('x')\n end",
"def callwide_events()\n on :event => 'error', :next => '/error.json' # For fatal programming errors. Log some details so we can fix it\n on :event => 'hangup', :next => '/hangup.json' # When a user hangs or call is done. We will want to log some details.\nend",
"def transmit packets, delay: 0.1\r\n Ionian::Socket.new host: \"#{SOUNDWEB_IP}:#{SOUNDWEB_PORT}\" do |socket|\r\n packets.each do |packet|\r\n socket.write packet.pack(packet.map { 'C' }.join)\r\n socket.flush\r\n sleep delay\r\n end\r\n end\r\nend",
"def send_termination_event\n @message_handler.send_termination_event unless @message_handler.nil?\n end",
"def flush(events, key, teardown=false)\r\n @logger.info(\"Flush #{events.length} events\")\r\n send_data(events.to_json, key)\r\n end",
"def add_closed_port_guard\n EventBus.subscribe(/.*/) do |event|\n if !@open\n raise \"Send :open_for_traffic before sending messages\"\n end\n end\n end",
"def index\n @client_events = ClientEvent.all\n end",
"def sync_send\n sync_write.putc(\"!\")\n sync_write.flush\n end",
"def emit event, *args\n @services.emit event, self, *args\n end",
"def xmit\n if @lag.zero?\n if @to_server\n $fake_server_port.on_packet_receive(CONNECTION_ID, @data, @channel)\n else\n $fake_client_conn.on_packet(@data, @channel)\n end\n true\n else\n @lag -= 1\n false\n end\n end",
"def on_server_update(ev)\n\t\tif(cookies_are_tasty(ev.client,ev.cookie))\n\t\t\tev.client.is_nice=true\n\t\t\tmunch_on(ev.cookie)\n\t\tend\n\t\tif(not ev.client.is_nice)\n\t\t\tpost_event UnauthorizedConnectionEvent.new(ev.src)\n\t\t\treturn\n\t\tend\n\t\tif(ev.build_date!=SUPPORTED_VERSION)\n\t\t\tclient.post_event WrongVersionEvent.new(self,ev.build_date)\n\t\t\treturn\n\t\tend\n\t\tif(false==client.serialize_from_db())\n\t\t\tpost_event DbErrEvent.new(ev.src)\n\t\telse\n\t\t\tclient.post_event SlotListEvent.new(self,client)\n\t\tend\n\tend",
"def send_event(event)\n each { |actor| actor.mailbox.system_event event }\n end",
"def write!( event )\n # Not implemented\n end",
"def event_epoch()\n # Flush out idle clients, if any\n @clients.each do |_,client|\n if Time.now - client.var[:last_ping] > 300\n client.socket.close\n client = @clients.delete(client.socket)\n dispatch :connection_reset, client, \"ping timeout\"\n end\n end\nend",
"def listen \n response.headers[\"Content-Type\"] = \"text/event-stream\"\n redis = Redis.new\n\n key = \"/node/#{params[:event_id]}:change\"\n logger.info \"listen #{key}\"\n redis.subscribe(key) do |on|\n on.message do |event, data|\n response.stream.write \"event: update\\n\"\n response.stream.write \"data: \"+data+\"\\n\\n\"\n end\n end\n\n rescue IOError \n # Client disconnected\n ensure \n response.stream.close\n end",
"def send_event(event)\n @client.send_event(@klass.to_s, @id, event)\n self\n end",
"def dispatch_event(data)\n puts \"Event Dispatcher Invoked\"\n \n unless !data.has_key? \"type\"\n puts \"message type #{data['type'].to_s}\"\n \n # switch event action based on message type\n case data['type']\n when \"register\"\n puts \"user wishes to register. check auth_key first\"\n self.register(data)\n when \"subscribe\"\n puts \"user wishes to subscribe to a channel\"\n self.subscribe(data)\n when \"message\"\n # message: to:channel,from:uuid,type:message,text:message,visibility:private\n puts \"user wishes to send a message\"\n end\n \n else\n # if the socket is connected but no post_init data was sent\n # then we want to kill the connection, since this is probably an unauthorized\n # user....\n \n puts \"data doesn't have key type\"\n self.close_connection_after_writing\n end\n \n end",
"def send(message)\n ## empty\n end",
"def transmissions\n # Return only directly sent message (via #transmit)\n connection.transmissions.filter_map { |data| data[\"message\"] }\n end",
"def transmit_event\n # Extract just the old values from change_hash\n old_values = {}\n change_hash.each_pair do |k,v|\n old_values[k] = v[0]\n end\n case source_type\n when \"Instance\"\n if ['running', 'stopped'].include?(status_code)\n # If we look this up through the 'source' association, we end up with it being a stale object.\n instance = Instance.unscoped.find(source_id)\n # If we have a time_last_running, use it; otherwise, we just started and it's not populated yet\n start_time = instance.time_last_running || Time.now\n terminate_time = status_code == 'stopped' ? instance.time_last_stopped : nil\n # Because this is an after-save hook, rescue any possible exceptions -- if for some reason\n # we cannot save the Event, we don't want to abort the Instance update transaction.\n begin\n e = Aeolus::Event::Cidr.new({\n :instance_id => instance.id,\n :deployment_id => instance.deployment_id,\n :image_uuid => instance.image_uuid,\n :owner => instance.owner.username,\n :pool => instance.pool.name,\n :provider => instance.provider_account.provider.name,\n :provider_type => instance.provider_account.provider.provider_type.name,\n :provider_account => instance.provider_account.label,\n :hardware_profile => instance.hardware_profile.name,\n :start_time => start_time,\n :terminate_time => terminate_time,\n :old_values => old_values,\n :action => status_code\n })\n e.process\n rescue Exception => e\n logger.error \"Caught exception trying to save event for instance: #{e.message}\"\n return true\n end\n end\n # There is also a \"summary\" attribute on state changes, but we don't appear to need to check it\n when \"Deployment\"\n if ['some_stopped', 'first_running', 'all_stopped', 'all_running'].include?(status_code)\n deployment = Deployment.unscoped.find(source_id)\n begin\n # TODO - The Cddr method supports a :deployable_id, but we don't implement this at the moment\n e = Aeolus::Event::Cddr.new({\n :deployment_id => deployment.id,\n :owner => deployment.owner.username,\n :pool => deployment.pool.name,\n :provider => (deployment.provider.name rescue \"-nil-\"),\n :provider_type => (deployment.provider.provider_type.name rescue \"-nil-\"),\n :provider_account => (deployment.instances.first.provider_account.label rescue \"-nil-\"),\n :start_time => deployment.start_time,\n :terminate_time => deployment.end_time,\n :old_values => old_values,\n :action => status_code\n })\n e.process\n rescue Exception => e\n logger.error \"Caught exception trying to save event for deployment: #{e.message}\"\n return true\n end\n end\n end\n end",
"def event(data)\n # Prepare the event object.\n id = @next_event_id\n @next_event_id += 1\n event = data.merge :id => id, :server_ts => Time.now.to_f\n @events << event\n\n # Broadcast the event to users.\n @users.each do |user|\n next unless user.session\n user.session.sync_events\n end\n end",
"def unaway\n @socket << \"AWAY\"\n end",
"def send\n @sent_at = Time.now\n sender.publish(data, meta)\n self\n end",
"def notify\n # render :nothing => true\n end",
"def noop\n write_noop\n response_processor.consume_all_responses_until_mn\n end",
"def transmissions; end",
"def transmissions; end",
"def start_partial_sync\n while c = @serv.accept\n Thread.start do\n begin\n @threads << Thread.current\n loop do\n begin\n x = Dr2::Types.read(c, [Dr2::Types::Message,\n Dr2::Types::Error])\n receive x, c\n rescue Dr2::Types::EOFException\n break\n rescue Exception\n Dr2::Types.writer($!).write_dr2(c)\n end\n end\n ensure\n c.close rescue nil\n @threads.delete Thread.current\n end\n end\n end\n end",
"def send\n puts \"a fake implementation of `send`\"\n end",
"def send_logouts_to_all_clients\n @@clients.each do |client|\n client.logout_request if !client.sent_logout?\n end\n end",
"def observe_events(client)\n return unless enable_listener?\n queue = create_queue(client)\n client.subscribe(queue) do |message|\n event = Event.parse(message)\n handle_event(event)\n end\n end",
"def on_outbound\n nil\n end",
"def to_sse\n response = Thin::AsyncResponse.new(request.env, 200, 'Content-Type' => 'text/event-stream')\n response.send_headers\n\n output_stream = ActionController::Live::SSE.new(response, retry: 300, event: 'row')\n db_handler = DbHandler.new(output_stream)\n\n rethink_handle = rethink_query.em_run(NoBrainer.connection.raw, db_handler)\n\n pinger = EventMachine::PeriodicTimer.new(PING_INTERVAL) do\n output_stream.write('PING', event: 'ping')\n end\n\n response.callback do # aka client disconnected\n pinger.cancel\n rethink_handle.close\n end\n\n head -1 # aka throw :async\n end",
"def event_new_connection(client)\n client.var[:last_ping] = Time.now # Initialize ping-timeout variable\n if @motd[EMPTY_ROOM]\n select_send(MSG_SERVER, EMPTY_ROOM, @keyring.default.iv,\n server_encrypt(\"motd #{EMPTY_ROOM}#{@motd[EMPTY_ROOM]}\")\n ) { |x| x == client }\n end\nend",
"def call\n catch_event unless no_event_possible?\n end",
"def msc2108_sync_sse(since: nil, **params, &on_data)\n raise ArgumentError, 'Must be given a block accepting two args - data and { event:, id: }' \\\n unless on_data.is_a?(Proc) && on_data.arity == 2\n raise 'Needs to be logged in' unless access_token # TODO: Better error\n\n query = params.select do |k, _v|\n %i[filter full_state set_presence].include? k\n end\n query[:user_id] = params.delete(:user_id) if protocol?(:AS) && params.key?(:user_id)\n\n req = Net::HTTP::Get.new(homeserver.dup.tap do |u|\n u.path = \"#{api_to_path :client_r0}/sync/sse\"\n u.query = URI.encode_www_form(query)\n end)\n req['accept'] = 'text/event-stream'\n req['accept-encoding'] = 'identity' # Disable compression on the SSE stream\n req['authorization'] = \"Bearer #{access_token}\"\n req['last-event-id'] = since if since\n\n cancellation_token = { run: true }\n\n # rubocop:disable Metrics/BlockLength\n thread = Thread.new(cancellation_token) do |ctx|\n print_http(req)\n @http_lock&.lock\n http.request req do |response|\n @http_lock&.unlock\n break unless ctx[:run]\n\n print_http(response, body: false)\n raise MatrixRequestError.new_by_code(JSON.parse(response.body, symbolize_names: true), response.code) unless response.is_a? Net::HTTPSuccess\n\n # Override buffer size for BufferedIO\n socket = response.instance_variable_get :@socket\n if socket.is_a? Net::BufferedIO\n socket.instance_eval do\n def rbuf_fill\n bufsize_override = 1024\n loop do\n case rv = @io.read_nonblock(bufsize_override, exception: false)\n when String\n @rbuf << rv\n rv.clear\n return\n when :wait_readable\n @io.to_io.wait_readable(@read_timeout) || raise(Net::ReadTimeout)\n when :wait_writable\n @io.to_io.wait_writable(@read_timeout) || raise(Net::ReadTimeout)\n when nil\n raise EOFError, 'end of file reached'\n end\n end\n end\n end\n end\n\n stream_id = ('A'..'Z').to_a.sample(4).join\n\n logger.debug \"MSC2108 : #{stream_id} : Starting SSE stream.\"\n\n buffer = ''\n response.read_body do |chunk|\n buffer += chunk\n\n while (index = buffer.index(/\\r\\n\\r\\n|\\n\\n/))\n stream = buffer.slice!(0..index)\n\n data = ''\n event = nil\n id = nil\n\n stream.split(/\\r?\\n/).each do |part|\n /^data:(.+)$/.match(part) do |m_data|\n data += \"\\n\" unless data.empty?\n data += m_data[1].strip\n end\n /^event:(.+)$/.match(part) do |m_event|\n event = m_event[1].strip\n end\n /^id:(.+)$/.match(part) do |m_id|\n id = m_id[1].strip\n end\n /^:(.+)$/.match(part) do |m_comment|\n logger.debug \"MSC2108 : #{stream_id} : Received comment '#{m_comment[1].strip}'\"\n end\n end\n\n if %w[sync sync_error].include? event\n data = JSON.parse(data, symbolize_names: true)\n yield((MatrixSdk::Response.new self, data), event: event, id: id)\n elsif event\n logger.info \"MSC2108 : #{stream_id} : Received unknown event '#{event}'; #{data}\"\n end\n end\n\n unless ctx[:run]\n socket.close\n break\n end\n end\n\n break unless ctx[:run]\n end\n ensure\n @http_lock.unlock if @http_lock&.owned?\n end\n # rubocop:enable Metrics/BlockLength\n\n thread.run\n\n [thread, cancellation_token]\n end",
"def send(event, data = {})\n\t\t@ws.send({:event => event, :data => data}.to_json)\n\tend",
"def events\n # ignore messages from bots!\n\n case params[:type]\n when 'url_verification'\n logger.info \"verifying url\"\n render json: { challenge: params[:challenge] }\n when 'event_callback'\n return unless event_params[:bot_id].nil?\n\n render json: nil\n ProcessSlackMessageJob.perform_later(event_params.as_json)\n\n else\n logger.info '*'*10\n logger.info \"Unknown event type: #{params[:type]}\"\n logger.info params.inspect\n end\n end",
"def process_sync(events)\n return unless events.is_a? Hash\n @since = events['next_batch']\n broadcast(:sync, events)\n\n @rooms.process_events events['rooms'] if events.key? 'rooms'\n end",
"def events=(_); end",
"def send_all(messages, dry_run: false)\n raise NotImplementedError\n end"
] |
[
"0.6488268",
"0.610779",
"0.5970181",
"0.585048",
"0.5742572",
"0.5709255",
"0.56956774",
"0.5609447",
"0.55905026",
"0.556543",
"0.55187356",
"0.54473746",
"0.5432325",
"0.5431326",
"0.54287076",
"0.5398758",
"0.5393626",
"0.5393184",
"0.5379811",
"0.5358168",
"0.5323853",
"0.53161025",
"0.5291686",
"0.5287794",
"0.52696896",
"0.5248951",
"0.5223796",
"0.52098846",
"0.5200438",
"0.51879084",
"0.5182744",
"0.51753575",
"0.5171704",
"0.5158328",
"0.5151802",
"0.51208234",
"0.5101277",
"0.5093518",
"0.5091456",
"0.5030929",
"0.5030929",
"0.5030929",
"0.5030929",
"0.5030929",
"0.5030929",
"0.5030929",
"0.5030929",
"0.50103354",
"0.5009818",
"0.49985704",
"0.4995895",
"0.49731827",
"0.49624145",
"0.4950184",
"0.49454322",
"0.4944992",
"0.49436873",
"0.49420172",
"0.49390268",
"0.49349865",
"0.48954046",
"0.48920682",
"0.4886917",
"0.48860425",
"0.48814082",
"0.488013",
"0.4873159",
"0.4869882",
"0.4867025",
"0.486336",
"0.48621646",
"0.48569164",
"0.48479107",
"0.48449087",
"0.483872",
"0.48291087",
"0.48235023",
"0.48209345",
"0.48188737",
"0.48158318",
"0.4813123",
"0.4802745",
"0.47980452",
"0.47945654",
"0.47938812",
"0.47938812",
"0.47861016",
"0.4785296",
"0.4784693",
"0.47807208",
"0.47792268",
"0.4777369",
"0.4772165",
"0.477152",
"0.47682554",
"0.47491157",
"0.4748331",
"0.47480828",
"0.47470465",
"0.47367734"
] |
0.5081216
|
39
|
Returns the latest events to the client. Args: events:: an array of events; the code assumes these are the most recent events in the session's room
|
def respond_recent_events(events)
return if events.empty?
last_id = events.last[:id]
respond :last_event_id => last_id, :events => events
@last_event_id = last_id
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def sync_events\n events = @last_event_id ? @room.events_after(@last_event_id) :\n @room.recent_events(512)\n return if events.empty?\n respond_recent_events events\n end",
"def fetch_events\n params = {'calendarId' => CONFIG[:cal_id], \n 'orderBy' => 'startTime',\n #'timeMax' => Time.utc(CONFIG[:year].to_i + 1, 4, 1).iso8601, \n #'timeMin' => Time.utc(CONFIG[:year].to_i, 4, 1).iso8601,\n 'singleEvents' => 'True'}\n \n result = @client.execute(:api_method => @cal.events.list, :parameters => params)\n\n @events_list = []\n result.data.items.each do |item|\n @events_list << item\n end\n end",
"def events(events, opts = {})\n data, _status_code, _headers = events_with_http_info(events, opts)\n return data\n end",
"def latest_events\n events = get_stack_events.select do |event|\n event.timestamp > @last_time\n end\n\n @last_time = Time.now\n\n filter_events(events.sort_by(&:timestamp))\n end",
"def get_events()\n @client.make_request(:get, @client.concat_user_path(\"#{CALL_PATH}/#{id}/events\"))[0]\n end",
"def get_events\n response = request(:get, \"/devmgr/v2/events\")\n #status(response, 200, 'Failed to get current events from server')\n #JSON.parse(response.body)\n response\n end",
"def events_for target, event_types\n url = GITHUB_EVENT_API_END_POINT % target\n etag = @etag_hash[target]\n last_event = @last_event_hash[target]\n\n events_to_send = []\n page = 1\n while page <= 10\n result = @clnt.get(url, {client_id: @client_id, client_secret: @client_secret}, {\"If-None-Match\" => etag})\n break unless result.status_code == 200\n events = JSON.load result.body\n if page == 1 # etag and last event should be set when querying the very first page\n @etag_hash[target] = result.header[\"etag\"]\n @last_event_hash[target] = events[0]\n end\n\n events.each do |event|\n return events_to_send if last_event == event # no need to proceed\n events_to_send << event if event_types.accept? event\n end\n\n page += 1\n end\n\n events_to_send\n end",
"def fetch\n @start_time ||= (Time.current - 1.minute).to_i * 1000\n $mw_log.debug \"Catching Events since [#{@start_time}]\"\n\n new_events = @alerts_client.list_events(\"startTime\" => @start_time, \"tags\" => \"miq.event_type|*\", \"thin\" => true)\n @start_time = new_events.max_by(&:ctime).ctime + 1 unless new_events.empty? # add 1 ms to avoid dups with GTE filter\n new_events\n rescue => err\n $mw_log.info \"Error capturing events #{err}\"\n []\n end",
"def events\n object.events.last(10)\n end",
"def events\n response = self.class.get('/v1/events.json')\n response.code == 200 ? JSON.parse(response.body) : nil\n end",
"def fetch_events(app_name, env_name, options={})\n @event_fetched_times += 1\n set_env_ready(app_name, env_name, true) # assume env become ready after it spit out all the events\n\n unless @events # unrestricted mode for testing if no explicit events set\n return [generate_event_from_messages(['Successfully deployed new configuration to environment',\n 'terminateEnvironment completed successfully',\n 'Successfully launched environment',\n 'Completed swapping CNAMEs for environments'\n ], Time.now + @event_fetched_times), nil]\n end\n\n events = @events[env_key(app_name, env_name)][@event_fetched_times - 1]\n\n if options.has_key?(:start_time)\n start_time = Time.parse(options[:start_time])\n events = events.select { |e| e[:event_date] >= start_time }\n end\n\n if limit = options[:max_records]\n events = events[0..limit]\n end\n\n [events, nil]\n end",
"def events(*events)\n @events ||= nil\n @events = events if events.present?\n @events\n end",
"def index\n @events = Event.last_events(current_user, 3)\n end",
"def list_events(events, question)\n\n clear_screen\n\n events_hash = events.map.with_index(1) do |event|\n {name: event.name, value: event}\n end\n\n @prompt.select(question, events_hash, per_page: 20)\n\n end",
"def fetch_top_events(params={}, save_to_db=true)\n params = setup_params(params)\n self.model_class = ::Mixpanel::Event\n \n method_url = get_method_url('events', 'top')\n request_params = self.select_params(params, [:type, :limit, :bucket])\n request_params[:resource] = method_url\n \n data = send_request(request_params)\n \n is_empty = (data.blank? || data['events'].blank?)\n if save_to_db && !is_empty\n target_ids = get_target_ids(params) \n \n self.model_class.transaction do\n data['events'].each do |event|\n target_id = event['event']\n # Format to JSON data.\n json_data = {:events => event}.to_json\n \n self.insert_or_update(params, target_ids, \n target_id, json_data)\n end\n end \n end\n return data\n end",
"def get_events(args)\n\tapi_url = \"#{@base_url}/#{args[:collection]}/#{args[:key]}/events/#{args[:event_type]}\"\n\tdo_the_get_call( url: api_url, user: @user )\nend",
"def get_events\n Resources::Event.parse(request(:get, \"Events\"))\n end",
"def getRepositoryEvents\n\t\trespositoryEvents = @ghClient.repository_events(@repository.to_s)\n\t\trespositoryEventsRaw = JSON.parse(@ghClient.last_response.body)\n\n\t\tghLastReponse = @ghClient.last_response\n\n\t\twhile ghLastReponse.rels.include?(:next) do\n\t\t\tghLastReponse = ghLastReponse.rels[:next].get\n\t\t\trespositoryEventsRaw.concat(JSON.parse(ghLastReponse.body))\n\t\tend\n\n\t\t# Debug Code\n\t\t# puts \"Got Repository Events, GitHub rate limit remaining: \" + @ghClient.rate_limit.remaining.to_s\n\n\t\tif respositoryEventsRaw.empty? == false\n\t\t\trespositoryEventsRaw.each do |y|\n\t\t\t\ty[\"organization\"] = @organization\n\t\t\t\ty[\"repo\"] = @repository\n\t\t\t\ty[\"downloaded_at\"] = Time.now\n\t\t\t\tyDatesFixed = self.convertRepoEventsDates(y)\n\t\t\t\tself.putIntoMongoCollRepoEvents(yDatesFixed)\n\t\t\tend\n\t\tend\n\tend",
"def get_events()\n\t\tevents = []\n\n\t\t@DB[:events].order(:date).each do |event|\n\t\t\tnewTimeslots = []\n\t\t\t@DB[:timeslots].where(parent_table: 'events', parent_id: event[:'id']).each do |timeslot|\n\t\t\t\tnewTimeslots.push(DateTime.parse(timeslot[:'time']))\n\t\t\tend\n\n\t\t\tnewAttendees = []\n\t\t\t@DB[:attendees].where(parent_id: event[:'id']).each do |attendee|\n\t\t\t\tattendeeTimeslots = []\n\t\t\t\t@DB[:timeslots].where(parent_table: 'attendees', parent_id: attendee[:'id']).each do |timeslot|\n\t\t\t\t\tattendeeTimeslots.push(DateTime.parse(timeslot[:'time']))\n\t\t\t\tend\n\n\t\t\t\tnewAttendee = Attendee.new(attendee[:'name'], attendeeTimeslots)\n\t\t\t\tnewAttendees.push(newAttendee)\n\t\t\tend\n\n\t\t\tnewEvent = Event.new(event[:'name'], event[:'description'], newTimeslots, newAttendees, event[:'id'])\n\t\t\tif newEvent.get_date >= @epoch\n\t\t\t\tevents.push(newEvent)\n\t\t\tend\n\t\tend\n\n\t\treturn events\n\tend",
"def available_events\n\t\treturn current_room.events || []\n\tend",
"def events\n metadata['events'].sort_by! { |event| event['timestamp'] }\n end",
"def get_events(num_per_slice = 20, part_no = 0)\n self.events.order(created_at: :desc)\n .limit(num_per_slice)\n .offset(num_per_slice * part_no)\n end",
"def download_events(apiEngine)\n @events = []\n results = []\n results = apiEngine.client.execute!(\n :api_method => apiEngine.api.events.list,\n :parameters => {\n :calendarId => @ident,\n :singleEvents => true,\n :orderBy => 'startTime',\n :timeMin => @dateMin.iso8601,\n :timeMax => @dateMax.iso8601 })\n\n results.data.items.each do |event|\n if event.start.date_time\n fulldate = event.start.date_time.strftime(\"%B, %d, %Y\")\n month = fulldate.split(',')[0]\n day = fulldate.split(',')[1]\n year = fulldate.split(',')[2]\n else\n fulldate = event.start.date.to_s\n month = fulldate.split('-')[1].to_i\n month = I18n.t(\"date.month_names\")[month]\n day = fulldate.split('-')[2]\n year = fulldate.split('-')[0]\n end\n @events.push(Event.new(event.creator.email, year, month, day, :summary => event.summary))\n end\n end",
"def write_events(events, revision: nil)\n return if events.empty?\n expected_version = revision.nil? ? -2 : revision\n @client.retry_append_to_stream(@name, events, expected_version, max_retries: @max_retries)\n end",
"def events\n event.user.events.where(:timestamp => beginning...ending)\n end",
"def get_events\n # conditions = \"starttime >= '#{Time.at(params['start'].to_i).to_formatted_s(:db)}' AND endtime <= '#{Time.at(params['end'].to_i).to_formatted_s(:db)}'\"\n conditions = \"starttime >= '#{params['start'].to_time}' AND endtime <= '#{(params['end']+\" 23:59:59\").to_time}'\"\n if @profile\n @events = @profile.events.where conditions\n else\n conditions += \" AND profile_type = '#{event_params[:profile_type]}'\"\n @events = Event.where conditions\n end\n\n events = []\n @events.each do |event|\n events << {:id => event.id, :title => event.title, :description => event.description || \"Some cool description here...\", :start => \"#{event.starttime.iso8601}\", :end => \"#{event.endtime.iso8601}\", :allDay => event.all_day, :recurring => (event.event_series_id) ? true : false}\n end\n set_profile\n render :text => events.to_json\n end",
"def events *args\n Xmlstats::Endpoints::Events.fetch *args\n end",
"def event_all_new(events)\n event_all(events.stack, events.all.first.id)\n end",
"def event_all_new(events)\n event_all(events.stack, events.all.first.id)\n end",
"def latest_event(&blk)\n latest_event = nil\n page = 1\n count = 100\n loop do\n events = @client.issue_events(@issue.number, per_page: count, page: page)\n matching_events = events.select(&blk)\n latest_event = matching_events.last unless matching_events.empty?\n page += 1\n break if events.length < count\n end\n latest_event\n end",
"def get_events(trace: false, &block)\n r = dropbox_query(query: '2/team_log/get_events', trace: trace)\n r['events'].each(&block)\n while r['has_more']\n r = dropbox_query(query: '2/team_log/get_events/continue', query_data: \"{\\\"cursor\\\":\\\"#{r['cursor']}\\\"}\", trace: trace)\n r['events'].each(&block)\n end\n end",
"def get_events_get(startdate,\r\n events = nil,\r\n sort = nil,\r\n enddate = nil,\r\n offset = 0,\r\n limit = 10,\r\n subject = nil,\r\n xapiheader = nil,\r\n fromaddress = nil,\r\n email = nil)\r\n # Prepare query url.\r\n _path_url = '/events'\r\n _query_builder = Configuration.base_uri.dup\r\n _query_builder << _path_url\r\n _query_builder = APIHelper.append_url_with_query_parameters(\r\n _query_builder,\r\n {\r\n 'startdate' => startdate,\r\n 'events' => events,\r\n 'sort' => sort,\r\n 'enddate' => enddate,\r\n 'offset' => offset,\r\n 'limit' => limit,\r\n 'subject' => subject,\r\n 'xapiheader' => xapiheader,\r\n 'fromaddress' => fromaddress,\r\n 'email' => email\r\n },\r\n array_serialization: Configuration.array_serialization\r\n )\r\n _query_url = APIHelper.clean_url _query_builder\r\n # Prepare and execute HttpRequest.\r\n _request = @http_client.get(\r\n _query_url\r\n )\r\n CustomHeaderAuth.apply(_request)\r\n _context = execute_request(_request)\r\n # Validate response against endpoint and global error codes.\r\n if _context.response.status_code == 400\r\n raise APIException.new(\r\n 'API Response',\r\n _context\r\n )\r\n elsif _context.response.status_code == 401\r\n raise APIException.new(\r\n 'API Response',\r\n _context\r\n )\r\n elsif _context.response.status_code == 403\r\n raise APIException.new(\r\n 'API Response',\r\n _context\r\n )\r\n elsif _context.response.status_code == 405\r\n raise APIException.new(\r\n 'Invalid input',\r\n _context\r\n )\r\n end\r\n validate_response(_context)\r\n # Return appropriate response type.\r\n _context.response.raw_body\r\n end",
"def find_events(event)\n events = []\n name = event.name\n category = event.category\n description = event.description\n snapshots = find_project_snapshots(event.snapshot_id)\n snapshots.each do |snapshot|\n snapshot.events.reject { |e| e.name!=name || e.category!=category }.each do |event|\n events << event\n end\n end\n events\n end",
"def events\n @events ||= user_events.concat(org_events).uniq\n end",
"def events\n response.headers['Content-Type'] = 'text/event-stream' # Starts a Redis event stream (thread)\n room_id = params[:room_id]\n sse = Streamer::SSE.new(response.stream) # Opens server sent event stream\n redis ||= Redis.new # If the user doesn't already have a thread open, creates a new redis thread\n # --- Adds all the subscription events for each room --- \n redis.subscribe([\"add_message_#{room_id}\", \"remove_message_#{room_id}\", \"heart\"]) do |on|\n on.message do |event, data|\n if event == \"add_message_#{room_id}\" # For the add song subscription\n sse.write(data, event: \"add_message_#{room_id}\")\n elsif event == \"remove_message_#{room_id}\"\n sse.write(data, event: \"remove_message_#{room_id}\")\n end\n end\n end\n # --- end ---\n rescue IOError\n # Client disconnected\n redis.quit\n sse.close\n response.stream.close\n ensure\n # When not being used, threads close\n redis.quit\n sse.close\n response.stream.close\n end",
"def _convert_events(events)\n g_events = []\n events.each do |event|\n source = Google::Apis::CalendarV3::Event::Source.new(\n title: @cfg['calendar']['eventSource']['title'],\n url: @cfg['calendar']['eventSource']['url'],\n )\n g_event = Google::Apis::CalendarV3::Event.new(\n summary: event[:summary],\n location: event[:location],\n description: event[:description],\n start: _convert_to_calendar_time(event[:time]),\n end: _convert_to_calendar_time(event[:ends]),\n source: source,\n )\n g_events << g_event\n end\n g_events\n end",
"def events\n @events ||= []\n @events\n end",
"def all\n @events = Event.order(updated_at: :desc).page(params[:page]).per(10)\n end",
"def events\n data[\"events\"]\n end",
"def events(service, url, args)\n events = []\n ret = service.send_request(GData4Ruby::Request.new(:get, url, nil, nil, args))\n REXML::Document.new(ret.body).root.elements.each(\"entry\"){}.map do |entry|\n entry = GData4Ruby::Utils.add_namespaces(entry)\n e = GCal4Ruby::Event.new(service)\n if e.load(entry.to_s)\n events << e\n end\n end\n return events\nend",
"def get_since(timestamp, limit=20)\n uri = '/api/v1/pulses/events'\n params = {limit: limit, since: timestamp}\n events = []\n begin\n json_data = get(uri, params)\n page = json_data['next']\n\n params = URI::decode_www_form(URI(page).query).to_h unless page.nil?\n\n events += json_data['results']\n end while !page.nil?\n\n results = []\n events.each do |event|\n results << OTX::Event.new(event)\n end\n\n return results\n end",
"def fetch_next_week_events\n return [] unless sources.try(:first).present?\n\n source = sources.first\n source.refresh_token_if_expired\n\n gdata = Googledata.new\n gdata.pull(source.oauth_token)\n end",
"def events\r\n\tif session[\"fb_access_token\"].present?\r\n\t\t@graph = Koala::Facebook::API.new(session[\"fb_access_token\"])\r\n\t\t@string = @graph.get_connections(\"me\", \"events\")\r\n\t\t#@events.class\r\n\t\t#@events.first\r\n\tend\r\nend",
"def events\n return if @events.empty?\n @events.uniq.sort\n end",
"def all_events\n @unreads = current_user.unreads\n search_params = params.except(:utf8, :commit, :controller, :action, :page)\n if search_params.present?\n @events = Event.search(search_params, @unreads).order(\"created_at DESC\")\n @events = @events.paginate(:page => params[:page], :per_page => 5)\n else\n @events = Event.all.order(created_at: :desc).paginate(:page => params[:page], :per_page => 5)\n end\n end",
"def track_events(events)\n url = \"v2/#{account_id}/events/batches\"\n make_json_api_request :post, url, private_generate_resource(\"batches\", { \"events\" => events })\n end",
"def most_recent_commits(event_list)\n 5.times do |i|\n puts event_list[i][\"id\"]\n end\nend",
"def read_last_event(handle=@handle, source=@source, server=@server)\r\n buf = 0.chr * BUFFER_SIZE # 64k buffer\r\n read = [0].pack('L')\r\n needed = [0].pack('L')\r\n \r\n flags = EVENTLOG_BACKWARDS_READ | EVENTLOG_SEQUENTIAL_READ\r\n ReadEventLog(@handle, flags, 0, buf, buf.size, read, needed)\r\n \r\n event_source = buf[56..-1].nstrip\r\n computer = buf[56 + event_source.length + 1..-1].nstrip\r\n event_type = get_event_type(buf[24,2].unpack('S').first)\r\n user = get_user(buf)\r\n desc = get_description(buf, event_source)\r\n \r\n struct = EventLogStruct.new\r\n struct.source = event_source\r\n struct.computer = computer\r\n struct.record_number = buf[8,4].unpack('L').first\r\n struct.time_generated = Time.at(buf[12,4].unpack('L').first)\r\n struct.time_written = Time.at(buf[16,4].unpack('L').first)\r\n struct.event_id = buf[20,4].unpack('L').first & 0x0000FFFF\r\n struct.event_type = event_type\r\n struct.user = user\r\n struct.category = buf[28,2].unpack('S').first\r\n struct.description \t = desc\r\n \r\n struct\r\n end",
"def events(params = {})\n loop do\n begin\n return events!(params)\n rescue Podbay::TimeoutError\n # Keep waiting\n end\n end\n end",
"def event_list\n events_list\n end",
"def get_events\n events = [] \n @log ||= Rails.logger\n Appsterdam::Application.ical_subscriptions.each do |options|\n @log.info \"getting events from #{options[:url]}\"\n components = parse_ical(options[:url])\n events.concat(extract_events(components.first))\n end\n @log.info \"done importing iCal events.\"\n \n events\n end",
"def events_request(next_page_token = nil)\n params = {:calendarId => calendar_id}\n params.merge!(:pageToken => next_page_token) if next_page_token\n\n JSON.parse(client.execute(\n :api_method => calendar.events.list,\n :parameters => params).response.body)\n end",
"def events_request(max_pages=100)\n results = []\n max_pages.times do |page|\n # Repeatedly request events, page by page, until we reach the final page\n # of results (or for some maximum number of pages)\n req = MobilizeAmericaRequest.new(@api_key, @org_id, page+1)\n results += req.results\n break if req.last_page?\n end\n results\n end",
"def last_n_events_for_organization(n)\n events.order(created_at: :desc).limit(n)\n end",
"def parse_events(events)\n event_rows = []\n unless events.nil? || events.empty?\n events.each do |event|\n event_rows << [event['display_name'], \"http://confreaks.tv/events/#{event['short_code']}\", event_date(event['start_at']), event_date(event['end_at'])] if event_of_year?(event['short_code'])\n end\n return nil if event_rows.empty?\n Terminal::Table.new headings: ['Event', 'Link', 'Start date', 'End date'], rows: event_rows\n else\n nil\n end\n end",
"def events\n events = []\n now = Time.now\n @countdowns.times.each do |id, show_time|\n # Prevents extra refreshes\n latest_time = show_time.latest\n events << CalendarEvent.new(\n Shows.find_show(id.to_s).title,\n latest_time,\n latest_time + (60*60*3)\n ) unless (latest_time - now) > (60*60*24*7)\n end\n events.sort! {|a,b| a.start_time <=> b.start_time}\n end",
"def get_events\n if @user.uuid.present?\n @events = @user.events.active_events.page(params[:page])\n paginate json: @events, per_page: params[:per_page]\n elsif @user.uuid == \"guest\"\n @events = Com::Nbos::Events::Event.active_events.where(tenant_id: @user.tenant_id)\n render json: @events\n else\n render :json => {messageCode: \"bad.request\", message: \"Bad Request\"}, status: 400\n end\n end",
"def get_events(queue_id, last_event_id=nil)\n connection.params = build_get_event_params(queue_id, last_event_id)\n event_response.fetch(\"events\")\n end",
"def list_events\n result = ''\n $events.find.each do |doc|\n result << doc['location'] + ' at ' + doc['time'] + \"\\n\"\n end\n if result.empty?\n 'The database is currently empty.'\n else\n result\n end\nend",
"def events\n results = @client.execute(\n :api_method => @calendar.events.list,\n :authenticated => false,\n :parameters => {\n 'calendarId' => @config[:calendar_id],\n 'fields' => 'items(start,end,summary)',\n 'singleEvents' => true,\n 'orderBy' => 'startTime',\n 'timeMin' => DateTime.now.to_s,\n 'timeMax' => (DateTime.now + 7).to_s,\n 'q' => 'LIVE'\n }\n )\n\n results.data.items.map do |event|\n summary = event.summary.gsub(/^LIVE:\\s+/, '')\n CalendarEvent.new(summary, event.start.date_time, event.end.date_time)\n end\n end",
"def fetch_events(calendar_id)\n response = service.list_events(calendar_id,\n max_results: 5,\n single_events: true,\n order_by: \"startTime\",\n time_min: Time.now.iso8601,\n time_max: Date.today.+(1).to_time.iso8601)\n\n # filter out any declined events – they normally represent a clash or room release\n response.items.reject { |event|\n next if event.attendees.nil?\n event.attendees.all? { |attendee| attendee.response_status == \"declined\" }\n }\n end",
"def index\n @events = Event.order('updated_at DESC').page params[:page]\n end",
"def index\n @events = Event.order(:time).order(:date)\n \n fetch_calendar 'tgbgmclhk5gegn8t95fvqov0s8@group.calendar.google.com'\n end",
"def events(criteria: {}, tenants: nil)\n query = generate_query_params(criteria)\n uri = tenants ? '/admin/events' : '/events'\n http_get(uri + query, multi_tenants_header(tenants)).map { |e| Event.new(e) }\n end",
"def show_events\n @events = Event.order(\"created_at\").to_a\n end",
"def query\t\n\t\t if !org.nil?\t\n\t\t\t criteria = Event.includes(host: :org).where(orgs: {id: org.id})\n\t\t\t criteria = criteria.where(hosts: {id: host.id}) if !host.nil?\n\t\t\t events = criteria.order(occurred_at: :desc).take(SHOW_TOP) \n\n\t\t\t render json: events, status: 200\n\t\t else\n\t\t render_error \"Not Authrized to see all events. Required param not found. You sent #{params[:orgname]} and #{params[:hostname]}\", 422\t \n\t\t end\n\t\tend",
"def get_all_events\n events, cursor = get_paginated_first\n while cursor do\n next_events, cursor = get_paginated_next(cursor: cursor)\n events += next_events\n end\n events\n .map(&:to_i)\n end",
"def events\n data.events\n end",
"def upcoming_events\n [] || Event.where('event_start_date > :date AND event_end_date > :date AND status = :status', {date: Time.now.strftime('%Y-%m-%d'), status: Event.statuses.ready}).limit(3)\n end",
"def get_next_calendar_events\n next_events = JSON.parse search_for_future_calendar_events\n next_events[\"items\"]\n end",
"def top_events(action, date = default_date_range)\n additional_params = {\n flat: '1',\n filter_column: 'Events_EventAction',\n filter_pattern: action.to_s,\n filter_limit: '-1',\n filter_sort_column: 'nb_events',\n filter_sort_order: 'desc'\n }\n response = api_params('Events.getName', 'range', date, additional_params)\n response.map { |res| [res['Events_EventName'], res['nb_events']] }\n end",
"def buildEvents(events_json_response)\n\t\tevents = Array.new\n\t\t\n\t\tevents_json_response[\"results\"].each do |result|\n\t\t\tevent = {}\n\t\t\tevent[:name] = result[\"event_name\"]\n\t\t\tevent[:event_location] = \"#{result[\"neighborhood\"]}, #{result[\"street_address\"]}\"\n\t\t\tevent[:description] = result[\"web_description\"]\n\n\t\t\tarr = getCoordinates(\"#{result[\"neighborhood\"]}, #{result[\"street_address\"]}\")\n\n\t\t\tevent[:event_latitude] = arr[0] # lat\n\t\t\tevent[:event_longitude] = arr[1] # lon\n\t\t\n\n\t\t\t\n\t\t\tevents << event\n\t\t\t# Event.create!(events)\n\t\tend\t\n\n\t\tevents\n\n\tend",
"def show\n @events = fetch_events\n end",
"def get_last_event\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\n # Get the order ID\n order_id = params[:order_id].to_i\n scope_search = params[:scope] == 'public' ? ['public'] : ['public','private']\n\n @event = OrderEvent\n .includes(:user, :order)\n .joins(event: :tracking_milestone)\n .where(order_id: order_id, scope: scope_search)\n .order(created_at: :desc)\n .first\n\n if @event.blank? || @event.nil? then\n @last_event = {\n orderId: nil,\n createdAt: nil,\n placeOrder: 1,\n message: 'No events yet',\n observations: '',\n shipmentMethod: 'A',\n trackingMilestoneName: '',\n scope: 'private'\n }\n else\n @last_event = {\n orderId: @event.order_id,\n createdAt: @event.created_at,\n placeOrder: @event.event.tracking_milestone.place_order,\n message: @event.event.name,\n observations: @event.observations,\n shipmentMethod: @event.order.shipment_method,\n trackingMilestoneName: @event.event.tracking_milestone.name,\n scope: @event.scope\n }\n end\n \n respond_to do |format|\n format.json { render json: @last_event }\n end\n end\n end",
"def last_n_events(n)\n events.where(['date < ?', Date.today]).first(5)\n end",
"def events\n url = 'https://api.artic.edu/api/v1/exhibitions?limit=35'\n\n res = RestClient.get(url)\n JSON.parse(res)\nend",
"def events(params={})\n return Proxy.new(connection, \"./events\",params)\n end",
"def render_events(events)\n output = ''\n last_date = Date.parse('1970-1-1')\n events.each do |event|\n \n week, calendar_page = '',''\n \n unless last_date.strftime('%W') == event.start_date.strftime('%W')\n week = render_week(event.start_date)\n end\n unless last_date.day == event.start_date.day\n calendar_page = render_calendar_page(event.start_date)\n end\n \n output += render(:partial => 'events/event',:locals => {:event=>event, :week=>week, :calendar_page=>calendar_page})\n \n last_date = event.start_date\n \n end\n output\n end",
"def event_all(stack, evt_id = nil)\n evt_id = stack.last_event_token if evt_id\n results = all_result_pages(evt_id, :body,\n \"DescribeStackEventsResponse\", \"DescribeStackEventsResult\",\n \"StackEvents\", \"member\") do |options|\n request(\n :method => :post,\n :path => \"/\",\n :form => options.merge(\n \"Action\" => \"DescribeStackEvents\",\n \"StackName\" => stack.id,\n ),\n )\n end\n events = results.map do |event|\n stack.last_event_token = event[\"NextToken\"] if event[\"NextToken\"]\n Stack::Event.new(\n stack,\n :id => event[\"EventId\"],\n :resource_id => event[\"PhysicalResourceId\"],\n :resource_name => event[\"LogicalResourceId\"],\n :resource_logical_id => event[\"LogicalResourceId\"],\n :resource_state => event[\"ResourceStatus\"].downcase.to_sym,\n :resource_status => event[\"ResourceStatus\"],\n :resource_status_reason => event[\"ResourceStatusReason\"],\n :time => Time.parse(event[\"Timestamp\"]).localtime,\n ).valid_state\n end\n if evt_id\n idx = events.index { |d| d.id == evt_id }\n idx ? events.slice(0, idx) : events\n else\n events\n end\n end",
"def recent_events\n Event.includes(:user).where(group_id: self.id).limit(50).order(created_at: :desc).reverse\n end",
"def all_events\n @events = Event.all\n end",
"def get_current_events\n events = get_events\n current_events = []\n \n events.each do |event| \n if event.date > DateTime.now and event.date < DateTime.now + 2.months\n current_events << event\n end\n end\n \n return current_events\n end",
"def search_for_future_calendar_events\n uri = URI.parse(\"https://www.googleapis.com/calendar/v3/calendars/ufbobbo%40gmail.com/events?orderBy=startTime&singleEvents=true&timeMin=#{Time.now.strftime(\"%FT%T%:z\")}&fields=items(id%2Cstart)&key=#{ENV['GOOGLE_API_KEY']}\")\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n request = Net::HTTP::Get.new(uri.request_uri)\n response = http.request(request).body\n end",
"def list_events(criteria = {})\n events(criteria: criteria)\n end",
"def events_now\n\n # Open empty array\n events = []\n\n # Loop over all the calendars\n CALENDARS.each do |name, id|\n\n # Get the events\n cal_events = calendar(id).find_events_in_range(Time.now, Time.now + 60)\n\n # Loop over each one and add it to the array\n cal_events.each do |e|\n events << {event: e, cal: name} unless e.nil?\n end\n\n end\n\n # Return the final list\n return events\n\nend",
"def list_events\n puts \"Here are the most recent events at the Cuyahoga County Public Library:\"\n all_events = Trendster::Event.all\n all_events.each do |event|\n puts \"#{all_events.index(event) + 1}. #{event.name}\"\n end\n end",
"def from_events(events)\n events = [*events]\n existing = fetch_existing_map(events)\n events.map do |evt|\n new(id: evt.meetup_event_id,\n last_update: evt.meetup_last_update,\n existing_event: existing.fetch(evt.meetup_event_id, nil))\n end\n end",
"def events(args = nil)\n events = if args.nil? || args.eql?(:all)\n events = decode_response connection.get \"/calendar/feeds/#{id}/private/full\"\n events = events[\"feed\"][\"entry\"]\n events.map{ |event| Event.build_event(event, self)}\n elsif args.is_a?(String)\n Event.new({:id => args, :calendar => self}).fetch\n elsif args.is_a?(Hash)\n if args.is_a?(Hash) && args.has_key?(:id)\n Event.new({:id => args[:id], :calendar => self}).fetch\n else\n params = { \"start-min\" => args[:from],\n \"start-max\" => args[:to]}\n events = decode_response connection.get \"/calendar/feeds/#{id}/private/full\", params\n events = events[\"feed\"][\"entry\"]\n events = events.nil? ? [] : events.map{ |event| Event.build_event(event, self)}\n end\n else\n raise ArgumentError.new \"Invalid argument type #{args.class}\"\n end\n\n end",
"def events(dbname, &block)\n # can't use RestClient.get b/c of :block_response\n RestClient::Request.execute(:method => :get,\n :url => root_url('events', @storage, dbname),\n :headers => {:accept => \"text/event-stream\"},\n :block_response => block, &HANDLE_RESPONSE)\n end",
"def events( params={} )\n events = get_connections(\"events\", params)\n return map_connections events, :to => Facebook::Graph::Event\n end",
"def event_all_new(events)\n raise NotImplementedError\n end",
"def recent_commits\n public_events = @client.user_public_events @user[:login]\n public_events.select! { |e| e[:type] == \"PushEvent\" }\n commits = []\n public_events.each do |e|\n e[:payload][:commits].each do |c|\n c[:html_url] = \"https://github.com/#{e[:repo][:name]}/commit/#{c[:sha]}\"\n c[:shortcut] = \"#{e[:repo][:name]}@#{c[:sha][0..7]}\"\n end\n commits.concat e[:payload][:commits]\n end\n commits.take 15\nend",
"def events\n @events = registered_application.events.group_by(&:name)\n end",
"def owned_events\n events\n end",
"def events\n @even = @user.created_events.order('created_at DESC')\n @events = @even.paginate(:page => params[:page])\n end",
"def check_events\n temp = poll_response\n index = 0\n puts temp if $debug\n # begin\n if temp.has_key?(\"people\")\n temp[\"people\"].each do |user|\n unless @people_hash.has_key?(user[\"screenname\"])\n @people_hash[user[\"screenname\"]] = user\n end\n end\n end\n unless temp == {}\n # begin\n temp[\"events\"].each do |event|\n key = \"#{event['server_seqid']}#{event['type']}\"\n unless @hash[key] == event[\"server_gmt\"]\n # puts event\n @api.process(event, @people_hash[event['from']]||nil, key)\n @hash[key] = event[\"server_gmt\"]\n end\n\n end\n # rescue\n # puts \"*****\"\n #@log.debug temp[\"events\"]\n # puts \"*****\"\n # puts temp\n # end\n end\n # rescue Exception => e\n # puts e.message, e.backtrace\n # end\n\n end",
"def state_events(state)\n api_return = RestClient.get('https://app.ticketmaster.com/discovery/v2/events.json?stateCode=' + state + '&apikey=' + $ticket_master_api_key)\n JSON.parse(api_return)\nend",
"def event_list\n @_events\n end",
"def events\n @events ||= Array(context[:events]).reverse.map { |event| Concierge::SafeAccessHash.new(event) }\n end",
"def fetch_all_events(params={}, save_to_db=true)\n params = setup_params(params)\n self.model_class = ::Mixpanel::Event\n \n event_names = []\n if params[:event]\n if params[:event].is_a?(Array)\n event_names += params[:event]\n else\n event_names << params[:event]\n end\n else\n # Get names of events.\n event_names = self.fetch_event_names(params, false)\n end\n \n # Get events data.\n method_url = get_method_url('events')\n \n request_params = self.select_params(params, [:type, :unit, :interval, :format, :bucket])\n request_params[:resource] = method_url\n request_params[:event] = event_names.to_json\n puts \">>>>>>>>>>>>>>>>> #{request_params.inspect}\" \n event_data = send_request(request_params)\n puts \">>>>>>>>>>>>>>>>> #{event_data}\"\n # Detect event data is empty or not\n is_empty = (event_data.blank? || event_data[RESPONSE_KEYS[:legend_size]].to_i <= 0)\n if save_to_db && !is_empty\n self.model_class.transaction do \n # Get all target ids existing in DB, in order to detect data was changed or not.\n target_ids = get_target_ids(params)\n \n # Sample data:\n # {'data': {'series': ['2010-05-29',\n # '2010-05-30',\n # '2010-05-31',\n # ],\n # 'values': {'account-page': {'2010-05-30': 1,},\n # 'splash features': {'2010-05-29': 6,\n # '2010-05-30': 4,\n # '2010-05-31': 5,\n # }\n # }\n # },\n # 'legend_size': 2}\n\n # Goal: Store each event in a single record in DB. \n series_data = event_data['data']['series']\n values_data = event_data['data']['values']\n event_names.each do |event_name|\n event_values = values_data[event_name]\n next if event_values.blank?\n \n # Get only series related to the event.\n event_series = event_values.keys & series_data\n\n # Keep the original format of the event data (based on Mixpanel API spec).\n origin_data = {\n :data => {\n :series => event_series, \n :values => {event_name => event_values}\n },\n :legend_size => 1\n }\n \n # Format hash to JSON.\n json_data = origin_data.to_json\n \n self.insert_or_update(params, target_ids, \n event_name, json_data)\n end\n end\n end\n return event_data\n end"
] |
[
"0.6532706",
"0.65177745",
"0.64196754",
"0.64079034",
"0.63905776",
"0.6302563",
"0.6290795",
"0.6264137",
"0.62243485",
"0.6203742",
"0.61614037",
"0.6101372",
"0.606116",
"0.60109454",
"0.6009058",
"0.59525794",
"0.5936088",
"0.5912409",
"0.5903249",
"0.588616",
"0.5871029",
"0.58677214",
"0.5839165",
"0.5797369",
"0.57774657",
"0.57677877",
"0.57634073",
"0.57612425",
"0.57612425",
"0.5752471",
"0.57193106",
"0.57155293",
"0.57129496",
"0.57036847",
"0.56764877",
"0.5675223",
"0.5674743",
"0.56735194",
"0.5663311",
"0.56579053",
"0.56501627",
"0.5646357",
"0.5637937",
"0.5635109",
"0.5634138",
"0.5633163",
"0.5628945",
"0.56213796",
"0.56205046",
"0.5617716",
"0.55971956",
"0.55914843",
"0.5586184",
"0.5572602",
"0.5562713",
"0.55584437",
"0.55569535",
"0.55545425",
"0.5552901",
"0.5547133",
"0.5533382",
"0.55131006",
"0.55129385",
"0.5506194",
"0.55035025",
"0.5500131",
"0.5474619",
"0.54743296",
"0.5472402",
"0.54702055",
"0.5468832",
"0.5460065",
"0.54594624",
"0.54586023",
"0.5458047",
"0.5457353",
"0.5452449",
"0.5449019",
"0.54489046",
"0.54483616",
"0.54427594",
"0.5431777",
"0.5426033",
"0.54144406",
"0.54042095",
"0.53923637",
"0.53886664",
"0.5387082",
"0.5379534",
"0.5378488",
"0.53780454",
"0.5374505",
"0.5373911",
"0.5364581",
"0.53588396",
"0.53578776",
"0.5355822",
"0.534925",
"0.53452235",
"0.5341896"
] |
0.64814234
|
2
|
Returns data to the client.
|
def respond(data)
@ws.send JSON.unparse(data)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def data\n retrieve_data\n end",
"def request_data\n @data.to_json\n end",
"def call\n data\n end",
"def data\r\n @data\r\n end",
"def get_data\n response = proxy.get_data(handle)\n self.update_properties(response)\n self.partial = false\n self.persisted = true\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def get_data()\t\n\tend",
"def send_and_get_data data\n send_data data\n get_data_with_timeout data.size\n end",
"def data\n update_data\n @data\n end",
"def data\n self[:data]\n end",
"def data\n @datas\n end",
"def getData\n\t \t@data = {'command' => @command, 'params' => @params}\n \treturn @data\n\t end",
"def render\n data\n end",
"def data\n @raw_response.body\n end",
"def request_data; end",
"def get_data\n\t\texecute unless @result\n\t\treturn get_data_from_result(@result)\n\tend",
"def data; @data ||= fetch; end",
"def data\n _response_entity.fetch(\"data\", {})\n end",
"def data\n raise NotImplementedError\n end",
"def data\n @content\n end",
"def data\n construct_url\n JSON.parse(response)\n end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data; end",
"def data\n @_data ||= (@response['data'] || {})\n # ap @_data if ENV['GIZMO_DEBUG']\n end",
"def data\n return @data if @data\n\n raise 'response does not appear to be healthy' unless healthy?\n\n # TODO: make the driver.load file become load string.\n begin\n @data = Oj.compat_load(original.body)\n rescue Oj::ParseError => e\n raise \"could not parse data: #{e}\"\n end\n\n raise ServiceError, \"title: #{@data['title']} description: #{@data['description']} cid: (#{@data['correlationId']})\" if @data['isException']\n\n @data\n end",
"def send_data(&block)\n create_data do |data|\n tessen_api_request(data, &block)\n end\n end",
"def refresh!\n self.data = client.get(path).data\n end",
"def data\n _init\n\n respond_to do |format|\n format.xml { render xml: _data }\n format.json { render json: _data }\n end\n end",
"def _send_message data\n response << data\n end",
"def data\n case @response_type\n when :json\n ResponseBuilder::JsonOutput.new(@raw_data).data\n else\n nil\n end\n end",
"def read\n object = uy_connection.get(@path)\n object.data\n end",
"def data\n return @data if @data\n\n raise 'response does not appear to be healthy' unless healthy?\n\n begin\n @data = Oj.load(original.body)\n rescue Oj::ParseError => e\n raise \"could not parse data: #{e}\"\n end\n @data\n end",
"def data\n return @content.data\n end",
"def send data\n self.send(data.to_json)\n end",
"def request data, &blk\n json = JSON.generate data\n @dealer_sock.send json\n if block_given?\n blk.call JSON.parse(@dealer_sock.recv)\n end\n end",
"def as_received\n raw_data\n end",
"def reply(data)\n res.json(Satz.serializer.dump(data))\n end",
"def data\r\n {\r\n \"key\" => api_key,\r\n \"message\" => message,\r\n \"async\" => async,\r\n \"ip_pool\" => ip_pool,\r\n \"send_at\" => send_at\r\n }\r\n end",
"def get_data\n @data = []\n end",
"def response\n buffer_available_data\n @buffer[@cursor..-1]\n end",
"def data\n @data ||= `curl #{url} --digest --user #{username}:#{password}`\n end",
"def data\n DataProxy.new(self)\n end",
"def get_all\n @data\n end",
"def data\n self.reload if @should_reload\n return @data\n end",
"def fetch\n client.fetch(self)\n end",
"def receive_data(data)\n @client.send_command(SendDataCommand.new(@connection_id, data))\n end",
"def data\n @buffer.string\n end",
"def result\n response_as_json[\"data\"]\n end",
"def results\n response['data']\n end",
"def results\n send_query\n end",
"def data\n self.load if @data.nil?\n @data\n end",
"def data\n @data ||= @_data.respond_to?(:call) ? @_data.call() : @_data\n end",
"def return_data(data)\n @data_representation = data\n end",
"def results\n send_query\n end",
"def transmit_data\n body = {body: {datum:{data_type:\"float\", value: rand, virtual_entity_id: 1}}}\n self.class.post(API+'/data', body)\n end",
"def get_data(options)\r\n data = options[:data]\r\n\r\n data\r\n end",
"def all_data\n @data\n end",
"def twemproxy_data\n stats = TCPSocket.open(host, port)\n JSON.parse(stats.gets)\n end",
"def marshal\n @data\n end",
"def data\n @payload['data']\n end",
"def send(data)\n @client.send(data)\n end",
"def get_data\n raise \"overwrite it\"\n end",
"def data\n @data ||= EDN.read @body\n end",
"def body\n fetch\n @body\n end",
"def dalli\n @data\n end",
"def _print_out data\n\t\tresponse << \"Someone said: #{data}\"\t\t\t\n\tend",
"def data\n @data_t\n end",
"def getData\n return Marshal.load(@Data)\n end",
"def data(ctx: nil)\n _check_and_get(@_data, ctx)\n end",
"def send_data\n request = Collector::Request.\n new(self.api_location,\n :user => config[:htpasswd_user],\n :pass => config[:htpasswd_pass])\n\n # convert the array of object to a hash\n server = {\n websites: @websites.map{ |w| w.to_hash(@version).merge({server: config[:client_name].underscore }) }.map{ |w| w[:website] },\n name: config[:client_name].underscore\n }\n\n request.send(server)\n\n end",
"def raw_data\n @raw_data ||= api_url.open.read\n end",
"def printData()\n puts @data\n end",
"def do_data( data )\n @log.debug \"[#{@id}] got #{data.length} bytes\" if @log.debug?\n\n @data << data\n @progress_callback[@data] if @progress_callback\n\n if @length < 0 || @data.length < @length\n if @length < 0\n length = @chunk_size\n else\n length = @length - @data.length\n length = length > @chunk_size ? @chunk_size : length\n end\n\n @log.debug \"[#{@id}] requesting #{length} more bytes\" if @log.debug?\n @driver.read @id, @handle, @offset + @data.length, length\n @session.register( @id, self )\n else\n @callback[ OK, @data ]\n end\n end",
"def get\n if @data == nil\n url = make_url\n\n begin\n @data = Net::HTTP.get(URI.parse(url))\n rescue Exception => e\n @error = \"Unable to connect to #{url}\"\n end\n end\n\n return @data\n end",
"def response; return @response end",
"def get()\n return @http.request(@req)\n end",
"def data\n @data ||= decode_data(@body)\n end",
"def getJson\n render json: getData()\n end",
"def send(data)\r\n response = self.create_api_web_send_json(data)\r\n return response\r\n end",
"def data\n attributes.fetch(:data)\n end",
"def data\n attributes.fetch(:data)\n end",
"def read\n res = conn.get(escaped_path)\n @headers = res.headers\n res.body\n end",
"def data\n case response_object\n when Hash\n open_envelope(response_object)\n else\n response_object\n end\n end",
"def read\n res = conn.get(escaped_path)\n @headers = res.headers\n res.body\n end"
] |
[
"0.7244225",
"0.69633126",
"0.6941225",
"0.6868205",
"0.6835422",
"0.67675036",
"0.67142296",
"0.67142296",
"0.67142296",
"0.66895443",
"0.666878",
"0.666878",
"0.666878",
"0.6593646",
"0.6572515",
"0.6437289",
"0.64297575",
"0.6424078",
"0.6397313",
"0.6329542",
"0.63047373",
"0.62569296",
"0.62442577",
"0.62117547",
"0.6207139",
"0.61969995",
"0.6173893",
"0.61155814",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.609955",
"0.6099506",
"0.60678154",
"0.6065742",
"0.6055051",
"0.6024198",
"0.6018111",
"0.60127926",
"0.60075706",
"0.60049117",
"0.5998533",
"0.5996453",
"0.5992941",
"0.5976618",
"0.5973874",
"0.59638894",
"0.59536475",
"0.5953189",
"0.59288764",
"0.59279186",
"0.5916652",
"0.5904048",
"0.58979195",
"0.5890405",
"0.5881924",
"0.5876208",
"0.586234",
"0.58525383",
"0.5827441",
"0.5820764",
"0.58164173",
"0.5814594",
"0.5814217",
"0.5812478",
"0.5799313",
"0.579641",
"0.5788555",
"0.578426",
"0.5780916",
"0.5768288",
"0.5760731",
"0.5758558",
"0.5758015",
"0.5756454",
"0.57504976",
"0.5732662",
"0.5728468",
"0.57252854",
"0.5724087",
"0.5724074",
"0.57008916",
"0.5687546",
"0.5675184",
"0.56737137",
"0.56660354",
"0.566426",
"0.5661876",
"0.565258",
"0.565258",
"0.5650772",
"0.56489676",
"0.56489533"
] |
0.0
|
-1
|
CREATE TALLY METHOD TO KEEP TRACK TO TOTALS a hand would currently look like this: [["3", "Diamonds"], ["5", "Clubs"], ["3", "Hearts"], ["J", "Spades"], ["2", "Hearts"]]
|
def tally(hand)
arr = hand.map{|e| e[0]} #gets the second element of the nested array (cos arrays are zero indexed)
running_total = 0 #initialise this at the beginning & then iterate through each value to get the total from our new hand_total array
arr.each do |value|
if value == 'A'
running_total += 11
elsif value == 'J' || value == 'Q' || value == 'K' #could also say value.to_i ==0 because it would fail and return a 0
running_total += 10
else
running_total += value.to_i
end
end
# correct for Aces
arr.select{|e| e == "A"}.count.times do
running_total -= 10 if running_total > 21
end
running_total
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def calculate_total hand\n\ttotal=0\n\tarray = hand.map {|e| e[1]}\n\tarray.each do |card|\n\t\t## face card \n\t\tif card == \"10\" || card ==\"J\" || card ==\"K\" || card ==\"Q\"\n\t\t\ttotal +=10\n\t\t## Ace card\t\n\t\telsif card ==\"A\"\n\t\t\ttotal += 11\n\t\telse \n\t\t\ttotal += card.to_i\n\t\tend\n\tend\n\thand.collect {|e| e[1]}.each do |card|\n\t\tif total >21 && card == \"A\"\n\t\t\ttotal -= 10\n\t\tend\n\tend\n\n\treturn total \nend",
"def score\n # make a local array that will disappear when not in this method\n tally = []\n # for each of the cards in the hand, add their score to the tally from points\n @hand.each do |card|\n tally.push(@points[card])\n end\n # return the tally of the scores\n return tally.sum\nend",
"def total\n calculate_hand_totals\n if @hand.empty?\n puts \"Your hand is empty.\"\n return\n end\n\n puts \"Your hand is #{@hand.to_s}\" \n\n if !in_good_standing?\n puts \"*** YOU LOSE! ***\"\n end\n\n puts \"You have #{@hand_totals.count} possible total(s) with #{@hand_totals.count - 1} Aces:\"\n @hand_totals.each do | total, ace_distrobution |\n if total > 21\n puts \"BUSTED!- #{total} - [A: #{ace_distrobution[:hi]} hi, #{ace_distrobution[:lo]} lo]\"\n elsif total == 21 && @hand.count == 2\n puts \"BLACKJACK - #{total} - [A: #{ace_distrobution[:hi]} hi, #{ace_distrobution[:lo]} lo]\"\n elsif total == 21\n puts \"WINNING HAND - #{total} - [A: #{ace_distrobution[:hi]} hi, #{ace_distrobution[:lo]} lo]\"\n else\n puts \"#{total} - [A: #{ace_distrobution[:hi]} hi, #{ace_distrobution[:lo]} lo]\"\n end\n end\n end",
"def hand_value\n @hand_value = []\n if straight_flush?\n @hand_value << 9 << straight_flush?\n elsif four_of_a_kind?\n @hand_value << 8 << four_of_a_kind?\n elsif full_house?\n @hand_value << 7 << full_house?\n elsif flush?\n @hand_value << 6 << flush?\n elsif straight?\n @hand_value << 5 << straight?\n elsif three_of_a_kind?\n @hand_value << 4 << three_of_a_kind?\n elsif two_pair?\n @hand_value << 3 << two_pair?\n elsif pair?\n @hand_value << 2 << pair?\n else\n @hand_value << 1 << points[0]\n end\n\n end",
"def hand_value(hand)\n sum = 0\n hand.each do |card|\n sum += card\n end\n sum\n end",
"def calculate_total(hand) #[['2', 's'], ['a', 'd'], ... etc.] \n \n total = 0\n aces = 0\n hand.each do |card|\n if ['J', 'Q', 'K'].include?(card[0])\n total += 10\n elsif card[0] == 'A'\n aces += 1\n else \n total += card[0].to_i\n end\n end\n \n while aces > 0\n if total + 11 > 21\n total += 1\n else\n total += 11\n end\n aces -= 1\n end\n total\nend",
"def total (hand, current_total)\n # cards are nested arrays format like this: [\"H\", \"9\"] and [\"S\", \"9\"]\n # can extract out separate array of values only using .map, ignore suits\n string_values = hand.map { |card| card[1] } \n\n string_values.each do |value|\n current_total += get_int_value(value, current_total)\n end\n current_total\nend",
"def read_hand(name, hand_array, deck_hash)\n hand_val = sum_cards(hand_array, deck_hash)\n puts \"#{name}'s hand is now #{hand_array.join(\", \")} for a total of #{hand_val} points\"\n nil\nend",
"def calc_hand_total(cards)\r\n total = 0\r\n numbers_only_array = cards.map {|g| g[0]}\r\n numbers_only_array.each do |h|\r\n if h == 'ace'\r\n total += 11\r\n elsif h.to_i == 0\r\n total += 10\r\n else\r\n total += h.to_i\r\n end\r\n end\r\n\r\n numbers_only_array.select {|k| k == \"ace\"}.count.times do\r\n total -= 10 if total > 21 \r\n end\r\n\r\n total\r\nend",
"def analyze_hand\n pairs = 0\n straight = 0\n flush = 0\n\n # for now be conservative\n @play = 3\n\n # check for pairs\n\n\n # check for flush\n\n # check for straight\n\n\n\n # check for special hands\n #full house\n #royal flush\n #straight flush\n \n end",
"def deal_and_total(name, hand_array, deck_hash)\n read_hand(name, hand_array, deck_hash)\n new_hand_value = sum_cards(hand_array, deck_hash)\nend",
"def total_hands\n return @@total_hands\n end",
"def sum_cards(hand_array, deck_hash)\n hand_value = 0\n hand_array.each do |card_sym|\n hand_value += deck_hash[card_sym]\n end\n hand_value\nend",
"def get_player_total(player_hand)\n\tplayer_total = 0 \t\t# Total value of player's hand\n\n\tfor i in 0..player_hand.length - 1\n\t\tplayer_total += $cards[player_hand[i]]\n\tend\n\treturn player_total\nend",
"def count_cut\n bottom_card = $deck.last\n bottom_card = 53 if ['A', 'B'].include? bottom_card # joker's value is 53\n $deck = [$deck.slice(bottom_card, $deck.length - bottom_card - 1), $deck.slice(0, bottom_card), $deck.last].flatten\nend",
"def round()\n\t\t#array of used cards\n\t\t@used = []\n\t\t#loop through players array\n\t\tfor i in 0...@num_players\n\t\t\t#reset player variables\n\t\t\t@players[i].reset()\t\n\t\t\t#populate hand\n\t\t\t@players[i].populate(@used,52,5)\n\t\t\t#get hand rank\n\t\t\t@players[i].get_rank()\n\t\t\t#add hand to array of used cards\n\t\t\t@used += @players[i].hand\n\t\tend\n\t\t#increment round number\n\t\t@roundnum += 1 \n\tend",
"def get_hand_value(hand)\n hand_values = hand.map { |card| card[0]} \n \n total = 0\n #check if there are any Aces\n hand_values.each do |value|\n if value == 'A'\n total += 11\n elsif value.to_i == 0 # this is for J, Q, K\n total += 10\n else\n total += value.to_i\n end\n end\n # To accomodate Aces, subtract 10 from the total per Ace if the total is >21\n hand_values.select{|value| value == \"A\"}.count.times do \n total -= 10 if total >21\n end\n total\nend",
"def sum_player_hand(player_hand)\n player_hand.reduce(:+)\n end",
"def card_total(hand)\n total = 0\n ace = hand.select {|x| x[0] == 'A'}\n # Calculation of hand without aces.\n if ace == []\n hand.each do |x|\n x = x[0..-2].to_i\n x == 0? total += 10 : total += x\n end\n total\n else\n # Calculation of hand with ace(s)\n # Delete aces from hand array\n ace.each do |a|\n hand.each {|x| hand.delete(a) if x == a}\n end\n # Calculate hand without aces\n hand.each do |x|\n x = x[0..-2].to_i\n x == 0? total += 10 : total += x\n end\n ace.each {|a| hand << a}\n # Add the value of ace(s) to the current total\n nr_ace = ace.length\n case nr_ace\n when 1\n total <= 10? total += 11 : total += 1\n when 2\n total <= 9? total += 12 : total += 2\n when 3\n total <= 8? total += 13 : total += 3\n else\n total <= 7? total += 14 : total += 4\n end\n total \n end\nend",
"def pair(hand)\n\t\thand_num = check_num(hand)\n\t\ti = 0\n\t\thand_aux = Array.new()\n\t\twhile i < hand_num.size\n\t\t\thand_aux[i] = hand_num.count(hand_num[i])\n\t\t\ti += 1\n\t\tend\n\n\t\tsum = 0\n\t\tfor twos in hand_aux\n\t\t\tif twos == 2\n\t\t\t\tsum += 2\n\t\t\tend\n\t\tend\n\t\treturn sum / 4\n\tend",
"def dealTable(hands = 4, cards = 5)\n table = []\n hands.times do \n table << Hand.new\n end\n cards.times do\n table.each{|i| i.addCard(@cards.pop)} \n end \n return table\n end",
"def player_hand_total\n players_hand.inject(0) {|sum, card| sum + card.value}\n end",
"def hand_total(hand) \n\n #A flag to see if the hand contains an ace\n have_ace = ! ( session[hand].select{|card| card['rank'] == \"ace\"}.empty? ) \n\n total = 0 \n\n #Look up the point value of each card in the hand\n session[hand].each do |card|\n total += RANK_TO_POINTS[ card['rank']]\n end\n \n #Convert from hard (ace=1) to a soft (ace=11) \n #score if hand contains an ace\n #and it won't cause the hand to bust\n if (total <= 11 && have_ace) then total += 10 end \n\n return total \n\n end",
"def hand_score\n cards.map {|a| a.value}.sort {|a,b| a <=> b}.last\n end",
"def calcScore(hand)\n return hand.inject(0) { |sum, n| sum + n.points }\nend",
"def deal_hand no_of_cards\r\n @card_list.deal_hand no_of_cards\r\n end",
"def hand_deal\n hand = []\n 2.times do\n @card = self.random_card_deal\n hand.push(@card)\n end\n hand\n end",
"def hand_score(hand)\n\nend",
"def deal_hand no_of_cards\n @card_list.deal_hand no_of_cards\n end",
"def calculate_hand_total_value(hand_array)\n total_value = 0\n is_there_an_ace = false\n\n hand_array.each do |card|\n if card[:rank] === \"A\"\n is_there_an_ace = true\n end\n\n card_value = card[:value]\n total_value += card_value\n\n end\n\n if is_there_an_ace\n return [total_value, total_value + 10]\n\n else\n return [total_value, 999]\n\n end\n\nend",
"def render_hand\n p hand.map {|card| [card.value, card.suit]}\n end",
"def hand_count\n @hand_count ||= 0\n end",
"def hand_count\n @hand_count ||= 0\n end",
"def display_hand\n display_hand = []\n @hand.each do |h|\n display_hand << \"#{create_hand(h)}\"\n end\n display_hand\n end",
"def hand_score(hand)\n points = {\n \"A\"=>4,\n \"K\"=>3,\n \"Q\"=>2,\n \"J\"=>1\n }\n\n score = 0\n hand.each_char { |char| score += points[char.upcase] }\n return score\nend",
"def straight_flush_wake(array)\n #to initialize the hash use '.new'\n hash = Hash.new(0)\n suit = array.first.suit\n #to get suit to increment\n array.each{|card| hash[card.suit] +=1}\n hash.keys.length == 1 && hash [suit] == 5\nend",
"def hands\n @game_stats['hands']\n end",
"def get_hand_sum(curr_hand) \n curr_hand.inject(0) { |sum, card| sum + card }\n end",
"def play_hand( hand )\n\tscore = Array.new( 10 )\n\n\tscore[ 0 ] = [ is_royal_flush( hand ) ]\n\tscore[ 1 ] = [ is_straight_flush( hand ) ]\n\tscore[ 2 ] = [ is_four_of_a_kind( hand ) ]\n\tscore[ 3 ] = [ is_full_house( hand ) ]\n\tscore[ 4 ] = [ is_flush( hand ) ]\n\tscore[ 5 ] = [ is_straight( hand ) ]\n\tscore[ 6 ] = is_three_of_a_kind( hand )\n\tscore[ 7 ] = is_two_pair( hand )\n\tscore[ 8 ] = [ is_one_pair( hand ) ]\n\tscore[ 9 ] = [ is_high_card( hand ) ]\n\t\n\treturn score\nend",
"def flush\n my_hand.group_by(&:suit).select { |_, hand_of_suit| hand_of_suit.count == 5 }.values.flatten\n end",
"def value(hand)\n # Sorting hack to get aces at the very end so we count them last\n hand.sort_by { |c| c.to_i != 0 ? c : c[0] - 81 }.reverse().inject(0) do |total,cur|\n if cur.to_i != 0\n total + cur # 2-10 case\n elsif [\"J\",\"Q\",\"K\"].include? cur\n total + 10 # J,Q, or K\n elsif cur == \"A\"\n if (total+11) > 21\n total + 1 # Count ace as 1\n else\n total+11 # Count ace as 11\n end\n end\n end\n end",
"def return *hands\n hands.each do |hand_or_cards|\n cards = (hand_or_cards.is_a?(CardDecks::Hand) ? hand_or_cards.cards : Array.wrap(hand_or_cards))\n @used += cards\n @inhand.delete_if {|c| cards.include?(c) }\n @hands.each {|h| h.cards.delete_if {|c| cards.include?(c) } }\n end\n end",
"def get_hand_value\n cards.reduce(0) { |hand_value, card| hand_value += card.value }\n end",
"def hand_value\n\t\tadd_card_value(all_sums = [[]])\n\t\tconvert_aces(all_sums)\n\t\tall_sums.map! do |value_set|\n\t\t\tvalue_set.inject :+\n\t\tend\n\t\treturn_sum(all_sums)\n\tend",
"def stockList(listOfArt, listOfCat)\n return \"\" if listOfArt == []\n result = []\n catHash = Hash.new {|value,key| value[key]=0}\n listOfArt.each {|x| cat, qty = x.split(\" \") ; catHash[cat[0]] += qty.to_i}\n\n listOfCat.each do |x|\n done = false\n catHash.each do |y|\n if x == y[0]\n result << \"(#{x} : #{y[1]})\"\n done = true\n end\n end\n result << \"(#{x} : 0)\" if !done\n end\n result.join(\" - \")\nend",
"def calculate_total(cards) #nested array of [['hearts', '3'], ['spades', '4']]\n\t#We want to create methods for extractable, reusable code\n\t#But the object must be in the same form\n\t#you don't have to explicitly indicate \"return\" when you want to render or puts a value, in ruby, the last line is \n\t#returned implicitly.\n\n\tarr = cards.map{|e| e[1] }\n\n\ttotal = 0\n\tarr.each do |value| \n\t\tif value == \"A\"\n\t\t\ttotal += 11\n\t\telsif value.to_i == 0 #if card value has no integer value (equals 0), add 10\n\t\t\ttotal += 10 #in instances of Jack, Queen, or King\n\t\telse\n\t\t\ttotal += value.to_i #if card has an integer value\n\t\tend\n\tend\n#correct for Aces\narr.select{|e| e == \"A\"}.count.times do\n\ttotal -= 10 if total > 21\t\n\tend\n\ttotal\nend",
"def hand_score\n score = self.tricks\n if !self.got_set\n score += 10\n end\n return score\n end",
"def calculate_total(cards)\r\n # [['H', '3'], ['S', 'Q'], ... ]\r\n\r\n arr = cards.map{|e| e[1]}\r\n \r\n total = 0\r\n arr.each do |value|\r\n if value == \"A\"\r\n total += 11\r\n elsif value.to_i == 0 # J, Q, K\r\n total += 10\r\n else\r\n total += value.to_i\r\n end\r\n # Logic for Aces\r\n end\r\n arr.select{|e| e == \"A\"}.count.times do\r\n total -= 10 if total > 21\r\n end\r\n\r\n return total\r\nend",
"def sum_of_cards(hand)\n card_values = hand.map do |card|\n if card[0] == 1\n card[0] = 11\n elsif card[0] >= 11\n card[0] = 10\n else\n card[0]\n end\n end\n sum = 0\n card_values.each do |card|\n sum += card[0]\n end\n sum\n end",
"def add_players_lowest_hand(current_player)\n sum_of_players_hand = 0\n if current_player == 1 then\n @player1_hand.each {|x|\n card_value = @deckhash.fetch(x)\n sum_of_players_hand = sum_of_players_hand + card_value\n # $stdout.write(\"Showing card and value #{x}, #{sum_of_players_hand}, #{card_value} \\n\")\n }\n end #end if current player = 1\n if current_player == 2 then\n @player2_hand.each {|x|\n card_value = @deckhash.fetch(x)\n sum_of_players_hand = sum_of_players_hand + card_value\n # $stdout.write(\"Showing card and value #{x}, #{sum_of_players_hand}, #{card_value} \\n\")\n }\n end #end if current player = 2\n if current_player == 3 then\n @player3_hand.each {|x|\n card_value = @deckhash.fetch(x)\n sum_of_players_hand = sum_of_players_hand + card_value\n # $stdout.write(\"Showing card and value #{x}, #{sum_of_players_hand}, #{card_value} \\n\")\n }\n end #end if current player = 3\n if current_player == 4 then\n @player4_hand.each {|x|\n card_value = @deckhash.fetch(x)\n sum_of_players_hand = sum_of_players_hand + card_value\n # $stdout.write(\"Showing card and value #{x}, #{sum_of_players_hand}, #{card_value} \\n\")\n }\n end #end if current player = 4\n# ### This method returns sum of player's hand\n return sum_of_players_hand\n end",
"def calculate_total(cards_of_player, cards_of_dealer)\n total_points=[]\n total_points[0] = calculate_points(cards_of_player)\n total_points[1] = calculate_points(cards_of_dealer)\n total_points\nend",
"def value_of_hand(array_of_cards)\n faces = {\"A\" =>11,\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 \"10\" => 10,\n \"J\" => 10,\n \"Q\" => 10,\n \"K\" => 10\n }\n total_value = 0\n num_aces = 0\n array_of_cards.each do |c|\n #cards are in string format, e.g. \"J of diamonds\"\n face = c.split[0]\n value = faces[face]\n total_value += value\n num_aces += 1 if face == \"A\"\n end\n #correct for Aces -- BORROWED THIS LOGIC FROM TEACHER'S CODE\n num_aces.times do\n total_value -= 10 if total_value > 21\n end\n return total_value\nend",
"def countSheeps2 array\n array.count(true)\nend",
"def initialize(cards)\n raise \"Invalid hand size - #{cards.length}\" unless cards.length == 5\n @cards = cards.map {|c| Card.new(c)}.sort\n @by_value = {}\n @by_suit = {}\n @cards.each do |c|\n @by_value[c.value] ||= []\n @by_suit[c.suit] ||= []\n @by_value[c.value] << c\n @by_suit[c.suit] << c\n end\n\n if @cards[4].value+1 == @cards[3].value &&\n @cards[3].value+1 == @cards[2].value &&\n @cards[2].value+1 == @cards[1].value &&\n @cards[1].value+1 == @cards[0].value\n end\n # Is it a straight\n @straight = true\n @cards.reduce do |p,c|\n if p.value != c.value + 1\n @straight = false\n break\n end\n c\n end\n value = [0]\n if @straight # Is it a straight\n value = [500, @cards.first.value]\n end\n # Is it a flush\n if @flush = @by_suit.find {|k,v| v.length == 5}\n if @straight\n value = [900, @cards.first.value]\n else\n value = [600, @cards.first.value]\n end\n end\n if value[0] < 700\n if (a = @by_value.find {|k,v| v.length == 3 }) &&\n (b = @by_value.find {|k,v| v.length == 2 })\n value = [700, a[0], b[0]]\n elsif a = @by_value.find {|k,v| v.length == 4 }\n value = [800, a[0]] # Is it 4 of a kind\n end\n end\n if value[0] < 500 && (a = @by_value.find {|k,v| v.length == 3 })\n value = [400, a[0]] # Is it 3 of a kind\n end\n if value[0] < 400 \n if (a = @by_value.select {|k,v| v.length == 2}).length > 0\n if a.length == 2\n hi,low = a[a.keys.max], a[a.keys.min]\n high = @cards - hi - low\n value = [300,hi.first.value, low.first.value, high.first.value]\n else\n pair = a[a.keys.first]\n high = (@cards - pair).first\n value = [200,pair.first.value, high.value]\n end\n else\n value = [100, @cards.first.value]\n end\n end\n @value = value\n end",
"def dealer_hand_total\n dealers_hand.inject(0) {|sum, card| sum + card.value}\n end",
"def display_hand(hand)\n card_names = {\n \"c2\" => \"the 2 of clubs\", \"c3\" => \"the 3 of clubs\", \"c4\" => \"the 4 of clubs\", \"c5\" => \"the 5 of clubs\", \"c6\" => \"the 6 of clubs\", \"c7\" => \"the 7 of clubs\", \"c8\" => \"the 8 of clubs\", \"c9\" => \"the 9 of clubs\", \"c10\" => \"the 10 of clubs\", \"cj\" => \"the jack of clubs\", \"cq\" => \"the queen of clubs\", \"ck\" => \"the king of clubs\", \"ca\" => \"the ace of clubs\",\n \"d2\" => \"the 2 of diamonds\", \"d3\" => \"the 3 of diamonds\", \"d4\" => \"the 4 of diamonds\", \"d5\" => \"the 5 of diamonds\", \"d6\" => \"the 6 of diamonds\", \"d7\" => \"the 7 of diamonds\", \"d8\" => \"the 8 of diamonds\", \"d9\" => \"the 9 of diamonds\", \"d10\" => \"the 10 of diamonds\", \"dj\" => \"the jack of diamonds\", \"dq\" => \"the queen of diamonds\", \"dk\" => \"the king of diamonds\", \"da\" => \"the ace of diamonds\",\n \"h2\" => \"the 2 of hearts\", \"h3\" => \"the 3 of hearts\", \"h4\" => \"the 4 of hearts\", \"h5\" => \"the 5 of hearts\", \"h6\" => \"the 6 of hearts\", \"h7\" => \"the 7 of hearts\", \"h8\" => \"the 8 of hearts\", \"h9\" => \"the 9 of hearts\", \"h10\" => \"the 10 of hearts\", \"hj\" => \"the jack of hearts\", \"hq\" => \"the queen of hearts\", \"hk\" => \"the king of hearts\", \"ha\" => \"the ace of hearts\",\n \"s2\" => \"the 2 of spades\", \"s3\" => \"the 3 of spades\", \"s4\" => \"the 4 of spades\", \"s5\" => \"the 5 of spades\", \"s6\" => \"the 6 of spades\", \"s7\" => \"the 7 of spades\", \"s8\" => \"the 8 of spades\", \"s9\" => \"the 9 of spades\", \"s10\" => \"the 10 of spades\", \"sj\" => \"the jack of spades\", \"sq\" => \"the queen of spades\", \"sk\" => \"the king of spades\", \"sa\" => \"the ace of spades, aww yeah!\"\n}\n puts \"Your hand contains the following cards:\"\n hand.each do |key, _|\n puts card_names[key]\n end\nend",
"def hand_value(cards)\n value = 0\n val_arr = []\n cards.each do |sub_array|\n val_arr << sub_array.last\n val_arr.sort!\n end\n val_arr.each do |val|\n if val == 11 && value > 10\n value = value + 1 \n else\n value = value + val\n end\n end\n return value\nend",
"def value_of_hand(hand)\n collection_of_card_values = hand.collect {|index| index[1]}\n card_values = collection_of_card_values.inject{|sum,next_card| sum + next_card }\n if collection_of_card_values.include?(1) && card_values < 12\n card_values += 10\n end\n card_values\nend",
"def hand_length\n return @cards_in_hand.length\n end",
"def analyse hand\n HandAnalyser.analyse hand\n end",
"def evaluate(hand) \n value = 0\n numerical_value = hand.map { |card| card[0]} \n numerical_value.each do |x| \n if ['K', 'Q', 'J'].include?(x)\n value += 10\n elsif x == 'A'\n value += 11\n else\n value += x.to_i\n end\n end\n \n hand.select {|x| x[0] == 'A'}.count.times do \n if value > 21\n value -= 10\n end\n end\n value\nend",
"def player_hits(deck, player_cards, dealer_cards, hand_totals)\n player_cards << deck.pop\n update_hand_totals(player_cards, dealer_cards, hand_totals)\nend",
"def royal_flush(hand)\nsuit_value = []\nface_value = []\n\thand.each do |card|\n\t\tface_value << card[0]\n\t\tsuit_value << card[1]\n\tend\n\t# suit_value = card_separator(hand)\n\t# If statement checking length of the suit value after suits are separated from royal flush => should all be \"d\" for diamonds(uniq removes all duplicates making the length 1)\n\tif suit_value.uniq.length == 1\n\t\t# Then if face_value inlcudes the [\"A\", \"K\", \"Q\", \"J\", \"T\"] faces, the hand1 value will return true\n\t\ttrue if face_value.include?(\"A\") && face_value.include?(\"K\") && face_value.include?(\"Q\") && face_value.include?(\"J\") && face_value.include?(\"T\")\n\tend\nend",
"def example4 poker_hands\n deck = PokerDeck.new\n deck.shuffle!\n hand = deck.hand\n num = 1\n while !poker_hands.include?(hand.poker_hand) do\n num += 1\n deck.shuffle!\n hand = deck.hand\n puts \"[#{num}] #{hand.coded_info}\"\n end\n puts '----'\n hand.order!\n puts \"The hand, coded and ordered: #{hand.coded_info}\"\n puts \"Same hand, ordered: #{hand}\"\n puts \"Poker hand type: #{hand.poker_hand}\"\n end",
"def reset\n\t\t@hand = Array.new\n\t\t@total = 0\n\tend",
"def smart_aces hand\n# Adjusts the value of \"Ace\" elements to be either 1 or 11 depending on the hand total\n\thand_total = hand.reduce :+\n\tif hand_total < 12 && hand_total > 2\n\t\thand.map! do |card|\n\t\t\tif card == 1\n\t\t\t\t11\n\t\t\telse\n\t\t\t\tcard\n\t\t\tend\n\t\tend\n\telsif hand_total > 21\n\t\thand.map! do |card|\n\t\t\tif card == 11\n\t\t\t\t1\n\t\t\telse\n\t\t\t\tcard\n\t\t\tend\n\t\tend\n\telsif hand_total == 2\n\t\thand[0] = 11\n\tend\n\nend",
"def get_hand\n\t\t12.times {\n\t\t\t@hand.push(@deck[@top_card])\n\t\t\t@top_card += 1\n\t\t}\n\t\t@start_time = Time.now\n\tend",
"def countSheeps array\n array.count(true)\nend",
"def look_at_tie(hand1,hand2)\n\t# Empty face_value1 array created for hand1 faces\n\tface_value1 = []\n\t# Empty face_value2 array created for hand2 faces\n\tface_value2 = []\n\n\thand1.each do |card|\n\t\t# Pushing the face of each card into the empty array and grabbing it by the first index. Ex: \"Kd\" => \"K\" (\"[0][1]\")\n\t\tface_value1 << card[0]\n\tend \n\t# Setting the face_changer function equal to the hand1_faces variable\n\thand1_faces = face_changer(face_value1)\n\t# Sorting the array of faces(after they go through facechanger they turn into integers)\n \tsorted_faces1 = hand1_faces.sort\n \tsorted_faces_sum1 = sorted_faces1.sum\n \t# new_hand1 puts non-duplicated elements into an array\n \tnew_hand1 =\tsorted_faces1.group_by { |card| card }.select { |k, v| v.size.eql? 1 }.keys\n \t# Finds the duplicates and returns one\n \thand1_dupes = sorted_faces1.select{|item| sorted_faces1.count(item) > 1}.uniq\n \t# Adds duplicates together\n \thand1_dupes_sum = hand1_dupes.sum\n \tnext_kicker1 = new_hand1.pop\n\thand2.each do |card|\n\t\tface_value2 << card[0]\n\tend\n\thand2_faces = face_changer(face_value2)\n \tsorted_faces2 = hand2_faces.sort\n \tsorted_faces_sum2 = sorted_faces2.sum\n \tnew_hand2 = sorted_faces2.group_by { |card| card }.select { |k, v| v.size.eql? 1 }.keys\n \thand2_dupes = sorted_faces2.select{|item| sorted_faces2.count(item) > 1}.uniq\n \thand2_dupes_sum = hand2_dupes.sum\n \tnext_kicker2 = new_hand2.pop\n\n \t# If hand1's duplicate sum is greater than hand2's duplicate sum then return the \"hand1 wins string\"\n\tif hand1_dupes_sum > hand2_dupes_sum \n\t\t\"Player One(hand1) wins!\" \n \t# If hand1's duplicate sum is less than hand2's duplicate sum then return the \"hand2 wins string\"\n\telsif hand1_dupes_sum < hand2_dupes_sum\n\t \t \"Player Two(hand2) wins!\"\n \t# If hand1's duplicate sum is equal to hand2's duplicate sum then go to next conditional\n\telse \n \tsplit_the_pot(hand1,hand2)\n end\nend",
"def deal_hand no_of_cards\n hand = Hand.new\n no_of_cards.times do\n hand.add pick_random\n end\n hand\n end",
"def score_hand\n\n end",
"def hand_value\n @hand_value = @player_hand.hand.flatten.map { |x| Integer(x) rescue nil}.compact.inject(:+)\n end",
"def finish_round\n @hands = []\n end",
"def play(hand,playTo)\n\t\n\tplayedCards = Array.new\n\t\n\t#push the correct number of cards to the cards played\n\tfor i in 0...playTo\n\t\tplayedCards.push(hand[i])\n\tend\n\n\t#remove played cards from hand\n\thand.shift(playTo)\n\n\t#returns hand for player and played cards for the game\n\treturn {\"handBack\" => hand, \"playedCards\" => playedCards}\n\nend",
"def hand_score(hand)\n\tcards= {\"A\"=>4, \"K\"=>3, \"Q\"=>2, \"J\"=>1}\n \tscore = 0\n \thand.each_char { |char| score += cards[char.upcase] }\n \treturn score\nend",
"def calculate_total(cards) \n # [['Hearts', '2'], ['Spades', 'Jack'], ...]\n total = 0\n arr = cards.map { |e| e[1] }\n\n arr.each do |card|\n if card == \"Ace\"\n total += 11\n elsif card.to_i == 0 # Jack, Queen, King\n total += 10\n else\n total += card.to_i\n end\n end\n\n # correct for Aces\n arr.select { |e| e == \"Ace\" }.count.times do\n total -= 10 if total > 21\n end\n\n total\nend",
"def count_cut\r\n temp = @deck[0..(@deck[-1] - 1)]\r\n @deck[0..(@deck[-1] - 1)] = []\r\n @deck[-1..-1] = [temp, @deck[-1]].flatten\r\n end",
"def bot_hand(player_hand)\n hand = @elements.key(most_frequent_move) || super\n @moves[player_hand] += 1\n\n hand\n end",
"def stockList(listOfArt, listOfCat)\n return \"\" if listOfArt.empty? || listOfCat.empty?\n listOfArt = Hash[listOfArt.map {|el| el.split ' '}]\n listOfArt.select! {|key, val| listOfCat.join.include? key[0] }\n listOfArt = Hash[listOfArt.values.map(&:to_i).zip(listOfArt.keys)].invert\n answer = Hash[listOfCat.product([0])]\n listOfArt.select do |key, val|\n if answer.has_key?(key[0])\n answer[key[0]] += val\n end\n end\n answer = answer.map{|k,v| \"#{k} : #{v}\"}.join(') - (').prepend('(') << \")\"\nend",
"def total_query\n\t\t@total = 0\n\t\t@cards_held.times do |x|\n\t\t\t@total += hand_query(x,1,0)\n\t\tend\n\t\treturn @total\n\tend",
"def hand_value (hand)\n hand_value = 0\n hand.each do |card|\n case card.value\n when /[2-9]|[1][0]/ \n hand_value += card.value.to_i \n when /[JQK]/\n hand_value += 10\n when \"A\"\n hand_value += 11\n if hand_value > 21\n hand_value -= 10 \n end \n end\n end\n hand_value\n end",
"def on_hand\n if self.assembly? && Spree::Config[:track_inventory_levels]\n parts.map{|v| v.on_hand / self.count_of(v) }.min\n else\n self.orig_on_hand\n end\n end",
"def discard\n\n # organize hand into sorted array of cards\n #### METHOD\n\n puts \"here is your hand #{hand}\"\n\n puts 'what cards? you can only discard 3.'\n\n #the player returns [2,3]\n ##### METHOD\n\n # find hand[2], hand[3] and remove from hand\n ##### METHOD\n\n # hand currently has 3 cards\n\n # hand << deck.deal(2)\n\n #RETURNS new hand\n\n\n #....player1.hand = the new hand\n end",
"def magic_weight\n binding.pry\n \n @result.arrayofcards.each do |bundle|\n \n end\n end",
"def calculatetotal(cards) # calculating the total of the two cards dealt, first to player then to dealer\n array = cards.map {|card| card[0]} # using the map method to lay out all the cards which are like so [[\"A\", \"S\"], [\"5\", \"C\"]]\n # We then only take the first element of the array and initialize that to the total\n total = 0 # total at the outset is zero\n array.each do |value|\n if value == \"A\" # in the event you get an ace card. \"A\" is as is unlike the bottom ones below\n total += 11 # total should now increase to 11\n elsif value.to_i == 0 # this is to cover for getting J, K, Q cards which defaults value to integer is zero\n total += 10\n else\n total += value.to_i\n end\nend # finished the array\n\n# Correcting Aces in case there are more than one. It should convert aces to 1 instead of 11 if total is more than 21\narray.select {|card| card.include?(\"A\")}.count.times do\n total -= 10 if total > 21\nend\ntotal # don't forget to include total here before exiting. IMPORTANT!!\nend",
"def sockMerchant(n, ar)\n count = {}\n ar.collect do |colour|\n if count[colour] == nil\n count[colour] = 1\n else\n count[colour] += 1\n end\n end\n total_pairs = 0\n count.collect do |key, value|\n total_pairs += (value / 2).floor\n end\n p total_pairs\nend",
"def total\n sum = 0\n hand.each do |card|\n sum += card.find_face_value\n end\n sum = correct_for_aces(sum)\n end",
"def calculate_total(cards) # [['H', '3'], ['S', 'Q']...]\n\tarr = cards.map{|e| e[1] }\n\n total = 0\n arr.each do |value|\n if value == \"A\"\n \ttotal += 11\n elsif value.to_i == 0 #J, Q, K\n \t\ttotal += 10\n else\n \ttotal += value.to_i\n end\n end\n\n #correct for Aces when total is over 21\n arr.select{|e| e == \"A\"}.count.times do\n \ttotal -= 10 if total > 21\n end\n\n total\nend",
"def get_hand_score\n score = 0\n \n # Add up score of non-aces\n values = hand.map{|card| card.value}\n values.each do |val|\n if Array(2..10).include?(val.to_i)\n score += val.to_i\n elsif [\"J\", \"Q\", \"K\"].include?(val)\n score += 10\n end\n end\n\n # deal with the aces\n values.count(\"A\").times do\n if score + 11 <= 21\n score += 11\n else\n score += 1\n end\n end\n\n return score\n end",
"def explain_the_situation(hand, who)\n v = value_of_hand(hand)\n puts \"#{who}'s cards are: #{hand.join(\", \")}\"\n puts \"They add up to: #{v}\"\nend",
"def test_get_hand_unordered_deck18\n\t\tgame = SetGame.new\n\t\tgame.deck = DECK_UNORDERED_18\n\t\tgame.hand = []\n\t\tgame.top_card = 0\n\t\tgame.get_hand\n\t\tassert_equal 12, game.hand.size\n\t\tassert_equal 12, game.top_card\n\t\tassert_equal CARD3, game.hand[0]\n\t\tassert_equal CARD4, game.hand[1]\n\t\tassert_equal CARD13, game.hand[2]\n\t\tassert_equal CARD8, game.hand[3]\n\t\tassert_equal CARD2, game.hand[4]\n\t\tassert_equal CARD15, game.hand[5]\n\t\tassert_equal CARD5, game.hand[6]\n\t\tassert_equal CARD9, game.hand[7]\n\t\tassert_equal CARD12, game.hand[8]\n\t\tassert_equal CARD10, game.hand[9]\n\t\tassert_equal CARD7, game.hand[10]\n\t\tassert_equal CARD11, game.hand[11]\n\tend",
"def songs_count\n value = 0\n packs.each do |pack|\n value += pack.songs.count\n end\n value += songs.count\n end",
"def draw_letters\n letters = [\n { character: \"a\", quantity: 9, score: 1 },\n { character: \"b\", quantity: 2, score: 3 },\n { character: \"c\", quantity: 2, score: 3 },\n { character: \"d\", quantity: 4, score: 2 },\n { character: \"e\", quantity: 12, score: 1 },\n { character: \"f\", quantity: 2, score: 4 },\n { character: \"g\", quantity: 3, score: 2 },\n { character: \"h\", quantity: 2, score: 4 },\n { character: \"i\", quantity: 9, score: 1 },\n { character: \"j\", quantity: 1, score: 8 },\n { character: \"k\", quantity: 1, score: 5 },\n { character: \"l\", quantity: 4, score: 1 },\n { character: \"m\", quantity: 2, score: 3 },\n { character: \"n\", quantity: 6, score: 1 },\n { character: \"o\", quantity: 8, score: 1 },\n { character: \"p\", quantity: 2, score: 3 },\n { character: \"q\", quantity: 1, score: 10 },\n { character: \"r\", quantity: 6, score: 1 },\n { character: \"s\", quantity: 4, score: 1 },\n { character: \"t\", quantity: 6, score: 1 },\n { character: \"u\", quantity: 4, score: 1 },\n { character: \"v\", quantity: 2, score: 4 },\n { character: \"w\", quantity: 2, score: 4 },\n { character: \"x\", quantity: 1, score: 8 },\n { character: \"y\", quantity: 2, score: 4 },\n { character: \"z\", quantity: 1, score: 10 },\n ]\n # letter_bucket creates an empty array that will be used to have a representative (gigantic) alphabet library\n letter_bucket = []\n letters.each do |letter|\n letter[:quantity].times do\n letter_bucket << letter[:character]\n end\n end\n # hand creates an empty array that will have 10 randomly drawn letters\n hand = []\n 10.times do \n hand << letter_bucket.slice(rand(0...letter_bucket.length)) \n end\n # restores the \"used\" letters to letter_bucket so they are not \"used up\"\n letter_bucket << hand\n letter_bucket.flatten!.sort!\n return hand\nend",
"def values\n hand = @hand.dup\n\n # Strip away cards' suits\n hand = hand.gsub(/(S|H|D|C)/, '')\n\n # Replace ace through ten cards with their numerical values\n hand = hand.gsub(/[AKQJT]/, 'A'=>'14', 'K'=>'13', 'Q'=>'12', 'J'=>'11', 'T'=>'10')\n\n # Return an array of integer values\n hand.split.map(&:to_i)\n end",
"def onalg_new_giocata(carte_player)\r\n @num_cards_on_deck = 40 - @num_cards_on_hand * @players.size - 4\r\n @table_cards = [] \r\n str_card = \"\"\r\n str_table = \"\"\r\n @cards_on_hand = []\r\n #p @num_cards_on_hand\r\n carte_player[0..@num_cards_on_hand - 1].each do |card| \r\n @cards_on_hand << card\r\n end\r\n carte_player[@num_cards_on_hand..-1].each do |card| \r\n @table_cards << card\r\n end\r\n @cards_on_hand.each{|card| str_card << \"#{card.to_s} \"}\r\n @table_cards.each{|card| str_table << \"#{card.to_s} \"}\r\n @players.each do |pl|\r\n @points_segno[pl.name] = 0\r\n end \r\n @log.info \"ALG:#{@alg_player.name} cards: #{str_card} table: #{str_table}\"\r\n end",
"def hand_value(hand) #calling upon function \"hand_value\". Getting hand (made up var. at the moment) \n value = 0\n for card in hand #do is a method. calling upon each card in the hand\n if $deck_values.keys.include?(card) # IF the keys of deck_values are included in the card, then..\n value += $deck_values[card] #value is equal to the card within deck_values\n else #otherwise, if value is NOT equal to the keys of deck_values, then value is equal to card\n value += card \n end\n end\n return value\nend",
"def show_hand hand=@hand\n\t\t#Output the title\n\t\tputs \"#\".center(5)+\"Color\".ljust(8)+\"Shading\".ljust(10)+\"Symbol\".ljust(10)+\"Number\"\n\t\tputs \"----------------------------------------\"\n\n\t\t#Output the cards\n\t\thand.length.times{ |card|\n\t\t\tputs \"#{card}\".rjust(3)+\": \"+\"#{hand[card].color}\".ljust(8)+\"#{hand[card].shading}\".ljust(10)+\"#{hand[card].symbol}\".ljust(10)+\" #{hand[card].number}\".rjust(3)\n\t\t}\n\n\t\t#Gives hint for easy development/testing\n\t\t# hint = []\n\t\t# find_set.each do |card| hint.push(@hand.index(card)) end\n\t\t# puts hint.to_s\n\tend",
"def full_house(hand)\n\t\tif (pair(hand) > 0 and three_of_a_kind(hand) > 0)\n\t\t\treturn 6\n\t\tend\n\t\treturn 0\n\tend",
"def print_hot100(list)\n\tcounter = 1\n\tlist.each do |makers, song|\n\t\tputs \"#{counter}. #{song} - #{makers}\"\n\t\tcounter += 1\n\tend\nend",
"def total_score\n total = 0\n @cards.each do |card|\n total += card.value\n end\n\n sorted_cards = @cards.sort\n\n straights = get_straight(sorted_cards).reverse\n straights.each do |straight|\n total += 40\n sorted_cards.slice!(straight[0]..straight[1])\n end\n\n three_cards = get_number_of_a_kind(sorted_cards, 3)\n three_cards.each do |three|\n total += 20\n sorted_cards.slice!(three[0]..three[1])\n end\n\n pairs = get_number_of_a_kind(sorted_cards, 2)\n pairs.each do |pair|\n total += 10\n sorted_cards.slice!(pair[0]..pair[1])\n end\n\n total\n end"
] |
[
"0.65477335",
"0.64149565",
"0.63654476",
"0.627301",
"0.62686116",
"0.6237541",
"0.62072265",
"0.61817276",
"0.61564887",
"0.61469185",
"0.6100209",
"0.6097997",
"0.609409",
"0.6091887",
"0.60677624",
"0.60031635",
"0.59898496",
"0.59854573",
"0.59734213",
"0.59586465",
"0.59582007",
"0.59560597",
"0.59321547",
"0.59001535",
"0.5897812",
"0.5895343",
"0.5882478",
"0.58763826",
"0.5860864",
"0.58584905",
"0.5812363",
"0.58106196",
"0.58106196",
"0.5806865",
"0.5797949",
"0.57877046",
"0.5786129",
"0.5761799",
"0.5744606",
"0.5739382",
"0.5712591",
"0.5712524",
"0.57051224",
"0.5704389",
"0.56971043",
"0.56960875",
"0.5684",
"0.5674888",
"0.5670224",
"0.5663352",
"0.565474",
"0.5639041",
"0.56322736",
"0.56306654",
"0.56253564",
"0.5621236",
"0.561511",
"0.56131923",
"0.5609456",
"0.56082374",
"0.5606205",
"0.5604264",
"0.56003946",
"0.5595384",
"0.5590636",
"0.55749685",
"0.5568324",
"0.5563505",
"0.555886",
"0.5556129",
"0.5542963",
"0.5538519",
"0.5529847",
"0.5529705",
"0.5508249",
"0.55077356",
"0.55063516",
"0.5505627",
"0.55004567",
"0.54996",
"0.5492405",
"0.54914415",
"0.549001",
"0.5485091",
"0.5481157",
"0.54761636",
"0.5445184",
"0.54410213",
"0.5434083",
"0.5431014",
"0.54263145",
"0.5424718",
"0.54226726",
"0.54077905",
"0.53968465",
"0.5380762",
"0.53770846",
"0.53734076",
"0.5366571",
"0.53617257"
] |
0.65437436
|
1
|
A B B C D update of tags is tricky in that it can produce three groups of changes: 1. tags being removed (exist on record, but not in params) 2. tags unchanged (exist both on record and in params) 3. tags being added (do not exiust on record but are passed in params)
|
def update_tags!
return unless @params.key?(:tags)
tags_to_remove.each do |tag_title|
TaskTag.where(task: task).joins(:tag).merge(Tag.where(title: tag_title)).destroy_all
end
tags_to_add.each do |tag_title|
TaskTag.where(task: task, tag: tag_from_title(tag_title)).first_or_create!
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n\n old_tags = @event.tags.pluck(:tag)\n new_tags = params[:tags].split(',')\n\n #logger.debug old_tags\n #logger.debug new_tags\n #logger.debug (old_tags - new_tags)\n #logger.debug (new_tags - old_tags)\n\n (old_tags - new_tags).each do |stag|\n @event.tags.where(tag: stag).first.destroy\n end\n\n (new_tags - old_tags).each do |stag|\n @event.tags.create(tag: stag)\n end\n\n respond_to do |format|\n if @event.update(event_params)\n format.html { redirect_to @event, notice: 'Event was successfully updated.' }\n format.json { render :show, status: :ok, location: @event }\n else\n format.html { render :edit }\n format.json { render json: @event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_with_tags(article_params, tag_ids, sub_tag_ids)\n # Load all tags from tag ids and load subtags of it to avoid n+1 query while fetching subtags for individual tags\n tags = Tag.where(id: tag_ids).includes(:sub_tags)\n\n # load article tags and subtags\n article_tags = self.tags\n article_sub_tags = self.sub_tags\n\n # new tags will be tags mapped to article on edit page - tags already associated with article\n new_tags = tags - article_tags\n\n # deleted tags will be tags already associated with article - tags mapped to article on edit page\n deleted_tags = article_tags - tags\n\n if tags.present? && sub_tag_ids.present?\n article_sub_tag_ids = article_sub_tags.map(&:id)\n\n # Convert subtag_ids to integer array, because we need to compare it with integer to load subtags under tags\n sub_tag_ids = sub_tag_ids.map(&:to_i) rescue []\n\n # Note: Here I am only subtags which are present under the tags, and here I need to select because\n # frontend functionality for filtering subtags according to tag is not complete\n # And I need to reject tags which are already associated with article\n new_sub_tags = tags.flat_map{ |tag| tag.sub_tags.select { |sub_tag| sub_tag_ids.include?(sub_tag.id) } }\n new_sub_tags.reject! { |sub_tag| article_sub_tag_ids.include?(sub_tag.id) }\n end\n\n sub_tags = SubTag.where(id: sub_tag_ids)\n\n deleted_sub_tags = []\n # put all subtags in deleted tags in deleted_sub_tags list\n deleted_sub_tags += deleted_tags.map(&:sub_tags) if deleted_tags.present?\n\n # add sub_tags already associated with article - sub_tags mapped to article on edit page to deleted subtags list\n deleted_sub_tags += article_sub_tags - sub_tags if sub_tag_ids.present?\n\n transaction do\n self.update_attributes!(article_params)\n\n self.tags << new_tags if new_tags.present?\n # here using delete to just remove association from article to tag not actual tag record\n self.tags.delete(deleted_tags) if deleted_tags.present?\n\n self.sub_tags << new_sub_tags if new_sub_tags.present?\n # here using delete to just remove association from article to sub_tag not actual sub_tag record\n self.sub_tags.delete(deleted_sub_tags) if deleted_sub_tags.present?\n end\n end",
"def update!(**args)\n @tags = args[:tags] if args.key?(:tags)\n end",
"def update!(**args)\n @tags = args[:tags] if args.key?(:tags)\n end",
"def my_set_tag_ids(new_tag_ids)\n old_tag_ids = self.tag_ids\n\n to_destroy = old_tag_ids - new_tag_ids\n to_create = new_tag_ids - old_tag_ids\n\n #whenever doing multiple updates, use this ActiveRecord call set-up to make sure that you have an all-or-nothing method call, which won't half-execute the action\n ActiveRecord::Base.transaction do\n Tagging.where(cat_id: self.id, tag_id: to_destroy).destroy_all\n to_create.each do |tag_id|\n Tagging.create!(cat_id: self.id, tag_id: tag_id)\n end\n end\n\n end",
"def add_or_update(tenant_id,entity_type_id,entity_id,tags)\n if tags.is_a?(Array)\n prev = self.get_tags(tenant_id,entity_type_id,entity_id)\n to_delete = prev - tags\n to_insert = tags-prev\n self.remove!(tenant_id,entity_type_id,entity_id,to_delete) if (to_delete && to_delete.length>0)\n self.add!(tenant_id,entity_type_id,entity_id,to_insert) if(to_insert && to_insert.length>0)\n end\n end",
"def update_tags\n tags=self.tag_ids.clone\n unless tags.nil?\n self.associations.each do |a|\n #destroy an association if its tag wasn't checked in the form\n a.destroy unless tags.include?(a.tag_id.to_s)\n #for each existing association, delete its tag from the parameters(to prevent duplicate associations)\n tags.delete(a.tag_id.to_s)\n end\n devs=Tag.find(:all,:conditions=>'type_id=4',:select=>'id').map{|d| d.id.to_s}\n genres=Tag.find(:all,:conditions=>'type_id=2',:select=>'id').map{|g| g.id.to_s}\n if (tags&devs).length==0\n indie=Tag.find_by_name('Independent')\n # if no developer has been selected, assume \"Independent\"\n self.associations.create(:tag_id=>indie.id)\n end\n if (tags&genres).length==0\n other=Tag.find_by_name('Other')\n # if no genre has been selected, assume \"Other\"\n self.associations.create(:tag_id=>other.id)\n end\n tags.each do |t|\n self.associations.create(:tag_id=>t) unless t.blank?\n end\n reload\n end\n end",
"def update\n\n tags = params[:tags]\n @piece.taggings.destroy_all\n\n tags.downcase.split(',').each do |tag_name|\n tag = Tag.find_or_create_by(name: tag_name.strip)\n @piece.taggings.create(user_id: current_user.id, tag_id: tag.id)\n end\n\n if @piece.update(piece_params)\n redirect_to @piece, notice: 'Piece was successfully updated.'\n else\n render :edit\n end\n end",
"def update_tags(tags)\n rescue_extra_data\n tags = tags.split(\",\").strip\n post_tags = post_type.post_tags\n post_tags = post_tags.where.not(name: tags) if tags.present?\n term_relationships.where(\"term_taxonomy_id in (?)\", post_tags.pluck(\"#{CamaleonCms::TermTaxonomy.table_name}.id\")).destroy_all\n tags.each do |f|\n post_tag = post_type.post_tags.where({name: f}).first_or_create(slug: f.parameterize)\n term_relationships.where({term_taxonomy_id: post_tag.id}).first_or_create\n end\n update_counters(\"tags\")\n end",
"def update_tags\n return unless tag_string\n new_tag_names = tag_string.split(\",\").map { |t| t.strip.downcase }\n current_tag_names = tags.collect(&:name)\n new_tag_names.each do |tag_name| \n unless current_tag_names.include? tag_name\n tag = Tag.where(name: tag_name)[0]\n tag = Tag.create! name: tag_name unless tag\n self.tags << tag \n end\n end\n tags.each { |t| (tags.remove t) unless (new_tag_names.include? t.name) }\n end",
"def update\n # creates tag objects for photos\n tag_array = tag_params['tags'].split(',').each do |x|\n x.strip!\n end\n tag_array.each do |x| \n if Tag.find_by(name: x)\n @tag = Tag.find_by(name: x)\n else\n @tag = Tag.create(name: x)\n end\n Tagging.create(photo_id: @photo.id, tag_id: @tag.id)\n end\n\n respond_to do |format|\n if @photo.update(photo_params)\n format.html { redirect_to @photo, notice: 'Photo was successfully updated.' }\n format.json { render :show, status: :ok, location: @photo }\n else\n format.html { render :edit }\n format.json { render json: @photo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n update_and_respond(@tag, tag_params)\n end",
"def update\n tag_array = event_params2['tags'].split(',')\n tag_array.each do |x|\n if Tag.find_by(desc: x)\n @tag = Tag.find_by(desc: x)\n else\n @tag = Tag.create(desc: x)\n end\n @event.tags << @tag\n # EventTag.create(event_id: @event.id, tag_id: @tag.id)\n end\n\n\n respond_to do |format|\n store_photos\n if @event.update(event_params)\n format.html { redirect_to @event, notice: 'Event was successfully updated.' }\n format.json { render :show, status: :ok, location: @event }\n else\n format.html { render :edit }\n format.json { render json: @event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_or_remove_tags(task)\n if params[:task][:tags].respond_to? 'each'\n params[:task][:tags].each do |tag|\n if tag[:status] == 'remove'\n task.tags.destroy(current_user_tags.find_by(name: tag[:name]))\n task.touch\n elsif tag[:status] == 'new'\n new_tag = Tag.find_or_initialize_by name: tag[:name], user_id: task.user_id\n if new_tag.new_record?\n new_tag.save\n task.tags << new_tag\n task.touch\n elsif !task.tags.exists?(name: new_tag.name)\n task.tags << new_tag\n task.touch\n end\n end\n end\n end\n end",
"def update\n @post = Post.find(params[:id])\n current_user.tag(@post, :with => params[:post][:tag_list], :on => :tags)\n respond_to do |format|\n if @post.update_attributes(params[:post])\n format.html { redirect_to(@post, :notice => 'Post was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @post.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n if @building.update(update_params)\n if t = params.permit(:tags)[:tags]\n tag_names = t.split(\", \")\n tags = [Tag.create_with(name: \"building\").find_or_create_by(name: \"building\")]\n for n in tag_names\n tags += [Tag.create_with(name: n).find_or_create_by(name: n)]\n end\n @building.tags = tags\n end\n @notice = \"Updated successfully.\"\n render :file => \"#{Rails.root}/public/success\", :layout => false\n else\n @notice = \"Update failed.\"\n render :file => \"#{Rails.root}/public/error\", :layout => false\n end\n end",
"def update\n @image_tags = ActsAsTaggableOn::Tag.all\n\n tag_list = params[:image][:tag_list]\n @image.tag_list = tag_list.keys.select{|t| tag_list[t] == \"1\"}\n\n\n respond_to do |format|\n if @image.update(image_params)\n format.html { redirect_to @image, notice: \"Image was successfully updated.\" }\n format.json { render :show, status: :ok, location: @image }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @image.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tags(elb_name, tag_changes)\n\n # First remove the tags that were deleted\n if !tag_changes.removed.empty?\n @elb.remove_tags({\n load_balancer_names: [elb_name],\n tags: tag_changes.removed.map { |t| { key: t.key } }\n })\n end\n\n # Update and add the other tags\n update_tags = (tag_changes.added + tag_changes.modified).map do |t|\n {\n key: t.key,\n value: t.local\n }\n end\n if !update_tags.empty?\n update_rollback(\"tags\", !tag_changes.removed.empty?,\n # update\n Proc.new {\n @elb.add_tags({\n load_balancer_names: [elb_name],\n tags: update_tags\n })\n },\n # rollback\n Proc.new {\n @elb.add_tags({\n load_balancer_names: [elb_name],\n tags: tag_changes.removed.map do |t|\n {\n key: t.key,\n value: t.aws\n }\n end\n })\n })\n end\n end",
"def update_tags(new_tags, old_tags)\n @tags += (new_tags || [])\n @tags -= (old_tags || [])\n @tags.uniq!\n tag_update = TagUpdate.new(@identity, new_tags, old_tags)\n @amq.fanout('registration', :no_declare => @options[:secure]).publish(@serializer.dump(tag_update))\n true\n end",
"def update\n @record = user_records.find(params[:id])\n current_user.tag(@record, with: double_escape_quotes(params[:record][:tag_list]), on: :tags)\n respond_with(@record)\n end",
"def update\n \n params[:product][:tag_ids] = Array.new\n params[:tags].split(\",\").each do |tag|\n tag_detail = Tag.where(\"title = ?\",tag).first\n if tag_detail.present?\n params[:product][:tag_ids] << tag_detail.id\n else\n new_tag = Tag.new(:title=>tag)\n new_tag.save\n params[:product][:tag_ids] << new_tag.id\n end\n end\n \n respond_to do |format|\n if @product.update(product_params)\n format.html { redirect_to @product, notice: 'Product was successfully updated.' }\n format.json { render :show, status: :ok, location: @product }\n else\n format.html { render :edit }\n format.json { render json: @product.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tags\n @updated = Tag.refresh_counts\n @deleted = []\n Tag.unused.order(:title).all.each do |tag|\n @deleted << tag.destroy\n end\n end",
"def update\n @task.tags.each { |t| t.delete}\n\n respond_to do |format|\n if @task.update(task_params)\n create_multiple_tags(task_params[\"tag\"], @task.id)\n\n format.html { redirect_to @task.list, notice: 'Task was successfully updated.' }\n format.json { render :show, status: :ok, location: @task }\n else\n format.html { render :edit }\n format.json { render json: @task.errors, status: :unprocessable_entity }\n end\n end\n end",
"def tag_with(tag_list, reload_tags = true)\n return remove_tags(self.tags) if tag_list.blank?\n new_tags = Tag.parse_to_tags(tag_list)\n tags_to_update = new_tags & self.tags\n tags_to_add = new_tags - self.tags\n tags_to_delete = self.tags - new_tags\n TxactionTagging.transaction do\n tags_to_update.each {|t| update_tagging(t) }\n tags_to_add.each {|t| create_tagging(t) }\n destroy_taggings(tags_to_delete) if tags_to_delete.any?\n update_attribute(:tagged, true)\n end\n\n self.taggings(reload_tags)\n return self.tags(reload_tags) # need to reload or AR doesn't see the changes\n end",
"def update\n new_tags = params[:problem].to_unsafe_h[\"tag_list\"].scan(/\\w+/)\n new_tags.each do |tag|\n @problem.tag_list.add(tag)\n end\n respond_to do |format|\n if @problem.save\n format.html { redirect_to @problem, notice: 'Question was successfully updated.' }\n format.json { render :show, status: :ok, location: @problem }\n else\n format.html { render :edit }\n format.json { render json: @problem.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n tags = equipment_params[:tags]\n\n tags_object_collection = []\n\n tags.each do |tag|\n if tag == ''\n next\n end\n\n tag_obj = Tag.find(tag)\n\n if tag_obj != nil\n tags_object_collection.push(tag_obj)\n end\n end\n\n new_equipment_params = equipment_params.except(:tags)\n\n @equipment = Equipment.find(params[:id])\n @equipment.tags = tags_object_collection\n\n respond_to do |format|\n if @equipment.update_attributes(new_equipment_params)\n format.html { redirect_to equipment_index_path, notice: 'Equipment was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @equipment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n params.permit(:tag_list)\n\n respond_to do |format|\n if @job.update(job_params)\n\n tag_names = params[:job][:tag_list].split(/,\\s+/)\n tag_names.each { |name|\n tag = Tag.find_or_create_by(name: name.strip)\n JobTag.find_or_create_by(:job_id => @job.id, :tag_id => tag.id)\n }\n\n format.html { redirect_to @job, notice: 'Job was successfully updated.' }\n format.json { render :show, status: :ok, location: @job }\n else\n format.html { render :edit }\n format.json { render json: @job.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n super\n\n if resource.save\n params.permit(:tags_interest_areas => [])\n @interest_tags = params[:tags_interest_areas]\n\n resource.interest_areas.destroy_all\n\n if not @interest_tags.nil?\n @interest_tags.each do |tag|\n temp_tag = Tag.find_by_tag_name(tag)\n if not temp_tag.nil?\n resource.interest_areas << temp_tag if not resource.interest_areas.include?(temp_tag) \n else\n resource.interest_areas << Tag.create(tag_name: tag)\n end\n end\n end\n\n params.permit(:tags_expertise_areas => [])\n @expertise_tags = params[:tags_expertise_areas]\n\n resource.expertise_areas.destroy_all\n\n if not @expertise_tags.nil?\n @expertise_tags.each do |tag|\n temp_tag = Tag.find_by_tag_name(tag)\n if not temp_tag.nil?\n resource.expertise_areas << Tag.find_by_tag_name(tag) if not resource.expertise_areas.include?(temp_tag) \n else\n resource.expertise_areas << Tag.create(tag_name: tag)\n end\n end\n end\n end\n end",
"def update\n @tags = params[:tags].split(',')\n @tagged = []\n for prev in Tagging.where(taggable_id: @question.id, taggable_type: 'Question')\n prev.destroy\n end\n respond_to do |format|\n if @question.update(question_params)\n @activity = Activity.create(user_id: current_user.id, activity_type: 'Update', target_type: 'Question', target_id: @question.id)\n for tag in @tags\n if !tag.blank?\n @tag = Tag.where(title: tag).first\n if @tag.blank?\n @tag = Tag.create(title: tag, user_id: current_user.id)\n end\n @tagging = Tagging.where(taggable_id: @question.id, taggable_type: 'Question', tag_id: @tag.id).first\n if @tagging.blank?\n @tagging = Tagging.create(taggable_id: @question.id, taggable_type: 'Question', tag_id: @tag.id)\n end\n end\n end\n format.html { redirect_to @question, notice: 'Question was successfully updated.' }\n format.json { render :show, status: :ok, location: @question }\n else\n format.html { render :edit }\n format.json { render json: @question.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tags_from_instagram(instagram_tags)\n current_tags = Tag.joins(:photo_tags).where(:photo_tags => {:photo_id => self.id, :sticky => false})\n new_tags = instagram_tags.map do |tag|\n Tag.find_or_create_by_name(tag)\n end\n self.tags.destroy(*(current_tags - new_tags))\n self.tags += new_tags\n rescue ActiveRecord::RecordNotUnique\n Rails.logger.warn \"I violated a unique key constraint when updating photo tags\"\n end",
"def update!(**args)\n @absent_tags = args[:absent_tags] if args.key?(:absent_tags)\n @present_tags = args[:present_tags] if args.key?(:present_tags)\n @v1_entry = args[:v1_entry] if args.key?(:v1_entry)\n end",
"def update\n @post = Post.find(params[:id])\n p_tags = params[:all_tags]\n p_tag_new = params[:tag_new]\n @post.category_id = request.POST[:category]\n @post.order_date = Time.current\n\n respond_to do |format|\n if @post.update_attributes(params[:post])\n\n if !p_tag_new.empty?\n tag_new = Tag.new(:tag_name => p_tag_new)\n if tag_new.save\n puts '--------------------------------------------------------------------------------'\n puts 'Save success.. Now p_tag is ', p_tags\n puts '--------------------------------------------------------------------------------'\n\n if p_tags.nil? || p_tags.to_s.empty? then\n p_tags = tag_new.id\n else\n p_tags = p_tags.to_s + ',' + tag_new.id.to_s\n end\n end\n end\n\n if !p_tags.to_s.empty?\n split_tags = p_tags.to_s.split(\",\")\n PostsTag.destroy_all(:post_id => @post.id) # destroy to accommodate all changes\n\n puts '--------------------------------------------------------------------------------'\n puts split_tags\n puts '--------------------------------------------------------------------------------'\n\n split_tags.each_index do |i|\n tag_id = split_tags[i]\n\n tag_map = PostsTag.new(:post_id => @post.id, :tag_id => tag_id)\n tag_map.save\n end\n end\n\n format.html { redirect_to @post, notice: 'Post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n #we do this here rather than in the model because we don't want timestamps\n #to update when tag implications are changed\n old_holder = {}\n assocs = %w[tag character source]\n # old_tags = @story.tag_ids.sort\n assocs.each do |assoc|\n old_holder[assoc] = @story.send((assoc + '_ids').to_sym).sort\n end\n\n pars = story_params\n if @story.update(pars)\n assocs.each do |assoc|\n #need to do this to force Rails to refresh from the DB\n @story.send((assoc + 's').to_sym).reload\n new_holder = @story.send((assoc + '_ids').to_sym).sort\n @story.touch unless old_holder[assoc] == new_holder\n end\n redirect_to @story, notice: 'Story was successfully updated.'\n else\n render :edit\n end\n end",
"def modify_tag tag\n data = {\n \"tag\" => params\n }\n temp = data[\"servers\"]\n data[\"servers\"] = { \"server\" => temp }\n\n json = JSON.generate data\n\n response = put \"tag/#{tag}\", json\n return response unless response.code == 200\n\n body = JSON.parse response.body\n body[\"tag\"]\n end",
"def update\n @tags_list = Tag.all\n @fact = Fact.find(params[:id])\n @fact.fact_text = params[:fact][:fact_text]\n @fact.page = params[:fact][:page]\n @fact.notes = params[:fact][:notes]\n @fact.last_modified_by = current_user.name\n @fact.tags.clear\n tags = params[:fact][:tags_attributes]\n Array(tags).each do |tag|\n if tag[1][:_destroy] != \"1\"\n temptag = Tag.find_by tag_word: tag[1][:tag_word]\n if @fact.tags.include?(temptag) == false\n @fact.tags << temptag\n end\n end\n end\n\n respond_to do |format|\n # Added by RB because updating wasn't working at all\n if @fact.update(fact_params)\n format.html { redirect_to @fact, notice: 'Fact was successfully updated.' }\n format.json { render :show, status: :ok, location: @fact }\n else\n format.html { redirect_to @fact, notice: 'Fact was sort of successfully updated. There was an error, but we think it is ok' }\n format.json { render :show, status: :ok, location: @fact }\n end\n\n\n end\n end",
"def update\n raise \"あなたのノートではありません。\" unless @note.user_notes[0].user_id == current_user.id\n note_attr = note_params\n tag_names = note_params[:tag].split(\" \")\n note_attr[:tag] = tag_names\n\n ActiveRecord::Base.transaction do\n Tag.add_count(tag_names, @note.tag)\n raise \"ノートの更新ができませんでした。\" unless @note.update_attributes(note_attr)\n end\n\n respond_to do |format|\n format.html { redirect_to @note, notice: 'Note was successfully updated.' }\n format.json { render :show, status: :ok, location: @note }\n end\n rescue => e\n respond_to do |format|\n format.html { render :edit }\n format.json { render json: @note.errors, status: :unprocessable_entity }\n end\n end",
"def update_tags(tags = nil)\n set_tags(tags)\n write_tags_to_repo\n read_tags_from_repo\n save!\n end",
"def update\n render json: @tag.errors unless @tag.update(tag_params)\n end",
"def update\n @song = Song.find(params[:id])\n\n params[:song].each do |tag, value|\n if TagInfo::USEFULL_TAGS.include?(tag)#tag on file is a useful tag\n @song[tag] = value #update the useful tag in DB\n end\n end\n respond_to do |format|\n begin\n Song.transaction do #update both file and DB or neither\n @song.update_tags_on_file(params[:song])\n @song.save!\n end\n format.html { redirect_to @song, notice: 'Song was successfully updated.' }\n format.json { head :ok }\n rescue Exception=>e\n format.html { render action: \"edit\" }\n format.json { render json: @song.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @destroy_tagging = Tagging.where(:blog_id => @blog.id).destroy_all\n params[:tags][:tag_id].each do |p|\n @tagging = Tagging.create(tag_id: p.to_i, blog_id: @blog.id)\nend\n respond_to do |format|\n if @blog.update(blog_params)\n\n format.html { redirect_to @blog, notice: 'Blog was successfully updated.' }\n format.json { render :show, status: :ok, location: @blog }\n else\n format.html { render :edit }\n format.json { render json: @blog.errors, status: :unprocessable_entity }\n end\nend\nend",
"def update_tags(tag_set, verbose: false)\n removed_tags = Set.new\n loop do\n previous_tags = tag_set.map{|t|t.to_s}\n\n implicate_tags(tag_set, removed_tags, verbose)\n alias_tags(tag_set, removed_tags)\n\n # Break when there is no change in tags.\n return tag_set if tag_set.map{|t|t.to_s} == previous_tags\n end\n end",
"def update\n @tags = tag_list_from_param\n respond_to do |format|\n if @note.update(note_params) && (@tags.empty? || Tag.update_note_tags(current_user, @note.id, @tags))\n format.html { redirect_to @note, notice: 'Note was successfully updated.' }\n format.json { render :show, status: :ok, location: @note }\n else\n format.html { render :edit }\n format.json { render json: @note.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n params[:post][:tag_ids] ||= []\n respond_to do |format|\n if @post.update_attributes(params[:post])\n format.html { redirect_to [@post.user, @post], notice: 'Post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @joke = Joke.find(params[:id])\n\n respond_to do |format|\n str_tags = params[:joke][:tags].split(',')\n @tags = str_tags.map {|tag_name|\n Tag.find_or_create_by_name(tag_name)\n }\n @joke.tags = @tags\n \n if @joke.update_attributes(params[:joke].except(:tags))\n format.html { redirect_to @joke, :notice => 'Joke was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @joke.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update_tags(new_tags, old_tags, &block)\n agent_check\n tags = @agent.tags\n tags += (new_tags || [])\n tags -= (old_tags || [])\n tags.uniq!\n\n payload = {:new_tags => new_tags, :obsolete_tags => old_tags}\n request = RightScale::IdempotentRequest.new(\"/mapper/update_tags\", payload)\n if block\n # always yield raw response\n request.callback do |_|\n # refresh agent's copy of tags on successful update\n @agent.tags = tags\n block.call(request.raw_response)\n end\n request.errback { |message| block.call(request.raw_response || message) }\n end\n request.run\n true\n end",
"def update\n @tags = params[:tags].split(',')\n @tagged = []\n for prev in Tagging.where(taggable_id: @lab.id, taggable_type: 'Lab')\n prev.destroy\n end\n respond_to do |format|\n if @lab.update(lab_params)\n\n for tag in @tags\n if !tag.blank?\n @tag = Tag.where(title: tag).first\n if @tag.blank?\n @tag = Tag.create(title: tag, user_id: current_user.id)\n end\n @tagging = Tagging.where(taggable_id: @lab.id, taggable_type: 'Lab', tag_id: @tag.id).first\n if @tagging.blank?\n @tagging = Tagging.create(taggable_id: @lab.id, taggable_type: 'Lab', tag_id: @tag.id)\n end\n end\n end\n\n if @lab.chkbxch == 1\n @activity = Activity.create(user_id: current_user.id, activity_type: 'Update', target_type: 'Lab', target_id: @lab.id)\n\n @coupling = Coupling.where(coupler_id: @lab.id, coupler_type: 'Lab', couplee_type: 'Channel' ).first\n if @coupling.blank?\n @name = t(:channel_coupled_to_lab) + ' ' + @lab.name\n @channel = Channel.create(name: @name, g_type: 2, i_type: 1, p_type: 1, user_id: current_user.id)\n @copuling = Coupling.create(coupler_id: @lab.id, coupler_type: 'Lab', couplee_id:@channel.id , couplee_type: 'Channel')\n end\n end\n if @lab.chkbxgr == 1\n @coupling = Coupling.where(coupler_id: @lab.id, coupler_type: 'Lab', couplee_type: 'Group' ).first\n if @coupling.blank?\n @name = t(:group_coupled_to_lab) + ' ' + @lab.name\n @group = Group.create(name: @name, g_type: 2, i_type: 1, p_type: 1, user_id: current_user.id)\n @copuling = Coupling.create(coupler_id: @lab.id, coupler_type: 'Lab', couplee_id:@group.id , couplee_type: 'Group')\n end\n end\n if @lab.chkbxbl == 1\n @coupling = Coupling.where(coupler_id: @lab.id, coupler_type: 'Lab', couplee_type: 'Blog' ).first\n if @coupling.blank?\n @name = t(:blog_coupled_to_lab) + ' ' + @lab.name\n @blog = Blog.create(title: @name, g_type: 2, i_type: 1, p_type: 1, user_id: current_user.id)\n @copuling = Coupling.create(coupler_id: @lab.id, coupler_type: 'Lab', couplee_id:@blog.id , couplee_type: 'Blog')\n end\n end\n\n if params[:lab][:avatar].blank?\n format.html { redirect_to '/labs?lab_id='+@lab.id.to_s, notice: :lab_was_successfully_updated }\n else\n format.html { redirect_to '/labs/cropper/'+@lab.id.to_s}\n end\n else\n format.html { render :edit }\n format.json { render json: @lab.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_or_create_tags\n return true if @inner_tags.nil? || !@save_tags\n words = []\n @inner_tags.each do |t|\n raise ActiveRecord::Rollback if t.new_record? && !t.save\n words << t.id\n tagging = Tagging.where(:taggable_id => self.id, :taggable_type => 'MediaElement', :tag_id => t.id).first\n if tagging.nil?\n tagging = Tagging.new\n tagging.taggable_id = self.id\n tagging.taggable_type = 'MediaElement'\n tagging.tag_id = t.id\n raise ActiveRecord::Rollback if !tagging.save\n end\n end\n Tagging.where(:taggable_type => 'MediaElement', :taggable_id => self.id).each do |t|\n t.destroy if !words.include?(t.tag_id)\n end\n end",
"def update\n @post = Post.find(params[:id])\n @tagarr = params[:post][\"tags_attributes\"][\"0\"][:name].split(\" \")\n puts @tagarr\n @tag = {}\n @tagarr.each_with_index do |tag,i|\n @tag[i] = {:name =>tag}\n end\n\n @tagreset = params[:post]\n @tagreset[\"tags_attributes\"] ={}\n @tagreset[\"tags_attributes\"] = @tag\n @post.tags=[]\n #puts @tagreset\n #render :layout => false\n respond_to do |format|\n if @post.update_attributes(@tagreset)\n format.html { redirect_to @post, notice: 'Post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @post = Post.find(params[:id])\n @post.tag_list = params[:tags]\n respond_to do |format|\n if @post.update_attributes(params[:post])\n format.html { redirect_to(@post, :notice => 'Post was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @post.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def save_new_tag_to_tag_table(tag_attributes)\n\n tag_attributes.split(\",\").each do |value|\n value=value.strip\n available_tag = Tag.where('tagname = ?', value).first #checking if added tag is available in the list/not.\n new_tag = Tag.create(:tagname => value) if available_tag.blank? #If it's a new tag then create and Add it to Tag list.\n available_tag.blank? ? self.insert_ids_to_post_tags(new_tag.id) : self.insert_ids_to_post_tags(available_tag.id) #Depending on tag available or it's a new tag, updating post_tags tag.\n end\n\n end",
"def update\n #@post = process_tags(@post)\n @post.save\n\n respond_to do |format|\n if @post.update(post_params.except(:tags))\n format.html { redirect_to @post, notice: 'Post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def change_tagname!(new_tagname)\n old_tagname = self.tagname\n if change_tagname?(new_tagname)\n # name change is ok - we use update_all because we assume our status is being updated up a level\n TagNomination.for_tag_set(owned_tag_set).where(:tagname => old_tagname).update_all(:tagname => new_tagname)\n return true\n end\n return false\n end",
"def update\n sql =\"UPDATE tags SET (tag_name) = ($1) WHERE id = $2\"\n values = [@tag_name, @id]\n SqlRunner.run(sql, values)\n end",
"def update\n if @tag.update(tag_params)\n render json: @tag\n else\n render json: @tag.errors, status: :unprocessable_entity\n end\n end",
"def update\n begin\n entity = Tagger::EntityTag.create_entity_tags(params)\n render json: { \"#{Tagger.tagged_resource}\": entity, tags: entity.tags }, status: 201\n rescue Exception => e\n render json: { error: \"Unprocessable entity\" }, status: 422\n end\n end",
"def update_tag_keyword(keyword,tags_set=[],args={})\n @tag_keyword[keyword] += tags_set\n @tag_blck[:keyword][keyword] += new_tags_set if args[:mode] && args[:mode] == :blck\n end",
"def update(current:, new:)\n ActiveRecord::Base.transaction do\n old_label = TagLabel.find_by!(tag: current)\n AdministrativeTag.find_by!(druid: identifier, tag_label: old_label)\n .update!(tag_label: TagLabel.find_or_create_by!(tag: new))\n old_label.destroy! if old_label.administrative_tags.count.zero?\n end\n rescue ActiveRecord::RecordNotUnique\n # This catches the exception triggered by the race condition because find_or_create_by! is not atomic.\n # If two threads are creating the same tag, one will get an exception.\n # We must catch this outside the transaction block, because once a constraint\n # is violated, PG will permit no more statements in that transaction.\n # When we go to rails 6 we can replace find_or_create_by with create_or_find_by: https://sikac.hu/use-create-or-find-by-to-avoid-race-condition-in-rails-6-0-f44fca97d16b\n\n @retry_count += 1\n raise if @retry_count > 5\n\n Rails.logger.warn(\"Possible race condition updating tag: #{current} with #{new}. This should only happen one time, otherwise this might be an error\")\n sleep(@retry_count)\n retry\n end",
"def update_tags(tags)\n Utils.assert_type(tags, \"tags\", Array)\n\n updates = tags.map.with_index do |tag, idx|\n Utils.assert_keys_present(tag, %i[key value], \"tags[#{idx}]\")\n mapping = P::IndexMapping.new(key: tag[:key], value: { value: tag[:value] })\n P::CustomerIndex.new(mapping: mapping, expires_at: tag[:expires_at])\n end\n command = P::UpdateCustomerTagCommand.new(**id_or_number, updates: updates)\n send_command(:update_customer_tag, command)\n end",
"def update_tags_value\n feature_value = FeatureValue.find(params[:feature_value_id])\n tag_id = params[:tag_id].to_i\n current_value = feature_value.value_genuine || []\n if current_value.include?(tag_id)\n current_value.delete(tag_id)\n else\n current_value << tag_id\n end\n feature_value.set_value(current_value, nil, nil, current_user)\n render :update do |page| end\n end",
"def update!(**args)\n @tagged_entry = args[:tagged_entry] if args.key?(:tagged_entry)\n end",
"def update\n if TagService.update(@tag, tag_params)\n flash[:notice] = t('views.message.update.success')\n else\n flash[:alert] = TagDecorator.flash(@tag, flash)\n end\n redirect_to tags_url\n end",
"def update!(**args)\n @created_tags_count = args[:created_tags_count] if args.key?(:created_tags_count)\n @deleted_tags_count = args[:deleted_tags_count] if args.key?(:deleted_tags_count)\n @updated_tags_count = args[:updated_tags_count] if args.key?(:updated_tags_count)\n end",
"def update\n # @post.delete_all_tags\n # @post.tag(post_params[:tags], current_user) if post_params[:tags]\n respond_to do |format|\n if @post.update_attributes(post_params)\n format.html { redirect_to @post, notice: 'Post was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @post.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_new_tag_to_tag_table(tag_attributes)\n\n tag_attributes.split(\",\").each do |value|\n value = value.strip\n is_a_new_tag = Tag.where(:tagname => value).blank?\n\n if is_a_new_tag\n new_tag = Tag.create(:tagname => value)\n insertion_query = \"INSERT INTO posts_tags(tag_id, post_id)VALUES(#{new_tag.id}, #{self.id});\"\n ActiveRecord::Base.connection.execute(insertion_query)\n end\n end\n end",
"def update_tags(tag_list, reload_tags = true)\n new_tags = Tag.parse_to_tags(tag_list)\n return tag_with(new_tags | self.tags, reload_tags)\n end",
"def update\n if @app && @tag\n @tag.update(tag_params)\n if @tag.valid?\n head :no_content\n else\n head :bad_request\n end\n else\n head :not_found\n end\n end",
"def update\n @post.update_attributes(post_params)\n @post.tag_list=(params[:tag_list])\n respond_with @post\n end",
"def update\n @post_job = PostJob.find(params[:id])\n @post = @post_job.post\n \n if (@post_job.update_attributes(params[:post_job]) && @post_job.post.update_attributes(params[:post]))\n sc = School.find(@post.school.id)\n sc.tag(@post_job, :with => params[:tag], :on => :tags)\n redirect_to post_job_url(@post_job)\n end\n \n end",
"def update\n respond_to do |format|\n if @question.update(question_params)\n \t# update tags\n \t@question.tag_with(params[:question][:tag_list])\n format.html { redirect_to @question, notice: 'Question was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @question.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n story = Story.find(params[:id])\n authorize story # check policies/story_policy.rb for auth rules\n\n if story_params[:tags]\n story_params[:tags].each do |tag|\n # If tag exists then use existing tag name\n if Tag.exists?(tag)\n story.tags << Tag.find_by_name(tag[\"name\"])\n else\n story.tags << Tag.new(tag)\n end\n end\n end\n\n if story.update(story_params.except(:tags)) && story.save\n response_with('Story successfully saved', 200)\n else\n response_with('Could not update story', 400)\n end\n end",
"def update\n respond_to do |format|\n if @show.update(show_params)\n\n params[:tags].each do |tag|\n\n show_tag = ShowTag.where(:name => tag[0]).last\n\n if show_tag #is this a real show_tag?\n\n show_tag_entry = ShowTagEntry.where(:show_id => @show.id, :show_tag_id => show_tag.id).last\n\n if tag[1] == \"true\" #if selected\n\n unless show_tag_entry\n\n ShowTagEntry.create(:show_tag_id => show_tag.id, :show_id => @show.id, :is_active => true)\n\n else\n\n show_tag_entry.update(:is_active => true)\n\n end\n\n\n else #if not selected\n\n if show_tag_entry\n\n show_tag_entry.update(:is_active => false)\n\n end\n\n end\n\n end\n\n end\n\n format.html { redirect_to show_home_path(@show.city, @show.url_slug), notice: 'Show was successfully updated.' }\n format.json { render :show, status: :ok, location: @show }\n else\n format.html { render :edit }\n format.json { render json: @show.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @tags = params[:tags].split(',')\n @tagged = []\n for prev in Tagging.where(taggable_id: @project.id, taggable_type: 'Project')\n prev.destroy\n end\n respond_to do |format|\n if @project.update(project_params)\n @activity = Activity.create(user_id: current_user.id, activity_type: 'Update', target_type: 'Project', target_id: @project.id)\n for tag in @tags\n if !tag.blank?\n @tag = Tag.where(title: tag).first\n if @tag.blank?\n @tag = Tag.create(title: tag, user_id: current_user.id)\n end\n @tagging = Tagging.where(taggable_id: @project.id, taggable_type: 'Project', tag_id: @tag.id).first\n if @tagging.blank?\n @tagging = Tagging.create(taggable_id: @project.id, taggable_type: 'Project', tag_id: @tag.id)\n end\n end\n end\n if params[:project][:avatar].blank?\n format.html { redirect_to '/projects?project_id='+@project.id.to_s, notice: :project_was_successfully_updated }\n else\n format.html { redirect_to '/projects/cropper/'+@project.id.to_s}\n end\n else\n format.html { render :edit }\n format.json { render json: @project.errors, status: :unprocessable_entity }\n end\n end\n end",
"def rebuild_taggings\n if @tags_updated\n tag_class = self.class.tag_class\n input = @tag_summary.split(',').map(&:strip).reject(&:blank?)\n existing = tags.all.map(&:name)\n deleted = existing - input\n added = input - existing\n\n # Remove taggings and check for orphaned tags\n unless deleted.empty?\n delete_query = [\"EXISTS (SELECT 1 FROM #{tag_class.table_name} WHERE name IN (?))\", deleted]\n taggings.where(delete_query).delete_all\n end\n\n # Create new taggings and tags (if nescessary)\n unless added.empty?\n added.each do |name|\n tag = tag_class.find_or_create_by(name: name)\n taggings.create(:tag => tag)\n end\n end\n\n # Delete orphaned tags\n self.class.tag_class.orphans.delete_all\n end\n end",
"def update\n @asset = Asset.find(params[:asset_id])\n @tag = @asset.tags.find(params[:id])\n\n respond_to do |format|\n if @tag.update_attributes(params[:tag])\n format.html { redirect_to(asset_manager_asset_tags_path(@tag.asset_id), :notice => 'Tag was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => :new }\n format.xml { render :xml => @tag.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def save_tags(delete_old_tags = true)\n #delete all old tags\n if (delete_old_tags)\n PostTag.delete_all(post_id: @post.id)\n end\n #save new tags\n if (params[:tags].length > 0)\n tags = params[:tags].split(',').uniq\n tags.each do |tag_name|\n tag_name = tag_name.downcase.strip\n tag = Tag.find_or_initialize_by(title: tag_name, for: Tag::TYPE_POST)\n if (tag.save)\n #save linked table\n postTag = PostTag.create(post_id: @post.id, tag_id: tag.id)\n postTag.save\n end\n end\n end\n end",
"def _UNDO_setTags(iNewTags)\n # Remove Tags that are not part of the new list\n @Tags.delete_if do |iTag, iNil|\n !iNewTags.has_key?(iTag)\n end\n # Add Tags that are not part of the current list\n iNewTags.each do |iTag, iNil|\n @Tags[iTag] = nil\n end\n end",
"def update\n @tags = params[:tags].split(',')\n @tagged = []\n for prev in Tagging.where(taggable_id: @channel.id, taggable_type: 'Channel')\n prev.destroy\n end\n respond_to do |format|\n if @channel.update(channel_params)\n @activity = Activity.create(user_id: current_user.id, activity_type: 'Update', target_type: 'Channel', target_id: @channel.id)\n for tag in @tags\n if !tag.blank?\n @tag = Tag.where(title: tag).first\n if @tag.blank?\n @tag = Tag.create(title: tag, user_id: current_user.id)\n end\n @tagging = Tagging.where(taggable_id: @channel.id, taggable_type: 'Channel', tag_id: @tag.id).first\n if @tagging.blank?\n @tagging = Tagging.create(taggable_id: @channel.id, taggable_type: 'Channel', tag_id: @tag.id)\n end\n end\n end\n if params[:channel][:avatar].blank?\n format.html { redirect_to '/channels?channel_id='+@channel.id.to_s, notice: :Channel_was_successfully_updated }\n else\n format.html { redirect_to '/channels/cropper/'+@channel.id.to_s}\n end\n else\n format.html { render :edit }\n format.json { render json: @channel.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tags\n if self.tags.any?\n self.tags.each do |tag|\n tag.update(owner: User.first)\n end\n end\n end",
"def save_or_destroy\n taggings.empty? ? destroy : save\n end",
"def delete(obj, tag)\n if not obj.tags.include?(tag)\n return false\n else\n obj[tag] = '' # Set to Nothing to Wipe Tag\n if obj.save\n return true\n else\n return false\n end\n end\nend",
"def remove_tag\n @asset = Asset.find(params[:id])\n tag_to_remove = params[:tag]\n \n @asset.tags = @asset.tags.select{|tag| tag.name != tag_to_remove}\n \n respond_to do |format|\n if @asset.save\n format.html { redirect_to(assets_url, :notice => 'Tag was successfully removed from asset.') }\n format.json { render :json => @asset }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @asset.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update_cached_tag_lists\n cache_tag_list if tag_list != cached_tag_list\n cache_topic_list if topic_list != cached_topic_list\n cache_user_tag_list if user_tag_list != cached_user_tag_list\n cache_owned_tag_list if owned_tag_list != cached_owned_tag_list\n end",
"def update\n\n if params[:tags_id].present?\n arr = params[:tags_id].split(',')\n @poem.tags = Tag.find(arr)\n end\n\n respond_to do |format|\n if @poem.update(poem_params)\n format.html { redirect_to @poem, notice: 'Poem was successfully updated.' }\n format.json { render :show, status: :ok, location: @poem }\n else\n format.html { render :edit }\n format.json { render json: @poem.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respondent = SurveyRespondent.find(params[:respondent_id])\n tag_context = params[:context] # tag context\n tag_list = params[:tags] # comma seperated list of tags\n\n if getTagOwner\n getTagOwner.tag(respondent, :with => tag_list, :on => tag_context)\n else\n respondent.set_tag_list_on(tag_context, tag_list) # set the tag list on the respondent for the context\n end\n \n respondent.save\n \n render :layout => 'content'\n end",
"def update\n @user = User.find(:id)\n @tag_list = configure_account_update_params[:tag_name].split(nil)\n if @user.update_attributes(configure_account_update_params)\n @user.save_tags(@tag_list)\n render json: {status: :success}\n end\n end",
"def add_tags(tag_list, reload_tags = true)\n new_tags = Tag.parse_to_tags(tag_list)\n\n tags_to_add = new_tags - self.tags\n if tags_to_add.any?\n TxactionTagging.transaction do\n tags_to_add.each {|t| create_tagging(t) }\n update_attribute(:tagged, true)\n end\n end\n\n self.taggings(reload_tags)\n return self.tags(reload_tags) # need to reload or AR doesn't see the changes\n end",
"def tag= tag\n @tag = tag\n update!\n end",
"def toggle_tags\n puts \"\\n\\n******* toggle_tags *******\"\n\n # == get post_id and tag_id from combined :ids string (e.g. 1_4)\n ids = params[:ids].split(\"_\")\n @post_id = ids[0]\n tag_id = ids[1]\n\n # == check post for selected tag\n @post_tag = PostTag.where(post_id: @post_id, tag_id: tag_id).first\n\n # == remove previously assigned tag\n if @post_tag\n puts \"******* HAS TAG (delete tag) *******\"\n @post_tag.destroy\n @post_tags = PostTag.where(post_id: @post_id)\n @post_tag_ids = @post_tags.map{|pt| pt.tag_id }\n puts \"@post_tag_ids: \", @post_tag_ids\n if @post_tag_ids.length == 0\n @post_no_tags = Tag.all\n else\n @post_no_tags = Tag.where(\"id NOT IN (?)\", @post_tag_ids)\n end\n puts \"@post_no_tags: \", @post_no_tags\n @tags = Tag.where(id: @post_tag_ids)\n render json: { tags: @tags, post_no_tags: @post_no_tags, post_id: @post_id}\n end\n end",
"def remove_tags(tags)\n\t\t\t@metadata.attributes.update do |u|\n\t\t\t\tu.delete(:tags => tags)\n\t\t\t\tu.add(:idenity => 1)\n\t\t\tend\n\t\t\treturn nil\n\t\tend",
"def update\n\n if params[:tags].nil?\n @question.tags = []\n else\n @question.tags = Tag.find(params[:tags])\n end\n\n respond_to do |format|\n if @question.update(question_params)\n format.html { redirect_to admin_question_path(@question), notice: 'Question was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @question.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n param_tags = params[:episode][:tags_list]\n params[:episode].delete(:tags_list)\n @episode.update_tags(param_tags, @episode)\n \n respond_to do |format|\n if @episode.update(episode_params)\n format.html { redirect_to [@serial,@season,@episode], notice: 'Episode was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @episode.errors, status: :unprocessable_entity }\n end\n end\n end",
"def save_tag(sent_tags)\n current_tags = self.tags.pluck(:tag_name) unless self.tags.nil?\n old_tags = current_tags - sent_tags\n new_tags = sent_tags - current_tags\n\n old_tags.each do |old|\n self.tags.delete PostTag.find_by(tag_name: old)\n end\n\n new_tags.each do |new|\n new_tag = Tag.find_or_create_by(tag_name: new)\n self.tags << new_tag\n end\n end",
"def update\n @entry = FeedEntry.find(params[:id])\n\n tags = params['tags' + params[:id]]\n\n respond_to do |format|\n if FeedEntry.add_tag(@entry, tags)\n format.html {render action: 'index'}\n format.json {head :no_content}\n else\n format.html {render action: 'index'}\n format.json {render json: @entry.errors, status: :unprocessable_entity}\n end\n end\n end",
"def update_tags(host_id, tags, source=nil)\n @tag_svc.update(host_id, tags, source)\n end",
"def update\n\n\t if current_user.is_admin\n\t @run = Run.find(params[:id])\n\n\t@run.name = params[:run][:name]\n\t@run.anz_staf = params[:run][:anz_staf]\n\t@run.anz_eps = params[:run][:anz_eps]\n\t\n\t@run.global = params[:run][:global]\n\ttag = params[:run][:tag].split(',')\n\t\ttf = Tag.new\n\t@run.tag= []\n\t@run.save\n\ttag.each do |name|\n\t\tputs name\n\t\tfind = false\n\t\tif Tag.all.size != 0\n\t\t\tTag.all.each do |ta|\n\t\t\t\tif ta.name == name\n\t\t\t\t\n\t\t\t\t\tfind = true;\n\t\t\t\t\ttf = ta\n\t\t\n\t\t\t\tend\n\t\t\tend\n\t\telse\n\t\t \ttn = Tag.create :name => name\n\t\tend\n\n\t\tif find\n\t\t\t@run.tag << tf\n\t\telse\n\t\t\ttn = Tag.create :name => name\n\t\t\t@run.tag << tn\n\t\tend\n\t\t\n\tend\n\n\t end\n\tif @run.save\n\t\tflash[ :notice] = \"Update success\"\n\telse\n\t\tflash[ :notice] = \"Update dismissed you may have missed something\"\n\tend\n\tredirect_to run_path params[:id]\n\t\t\n end",
"def update\n @note.update(body: note_params['body'])\n oldtag = @note.tag\n oldsecond = @note.second\n @note.update_tag(note_params['tag'].chomp.downcase, current_user.id)\n @note.update_second(note_params['second'].chomp.downcase, @note.tag.id, current_user.id)\n oldtag.cleanup\n oldsecond.cleanup\n respond_to do |format|\n if @note.save\n format.html { redirect_to notes_path, notice: 'Note was successfully updated.' }\n format.json { render :show, status: :ok, location: @note }\n else\n format.html { redirect_to notes_path, notice: @note.errors}\n format.json { render json: @note.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tag_record.update(tag_record_params)\n format.html { redirect_to @tag_record, notice: 'Record was updated.' }\n format.json { render :show, status: :ok, location: @tag_record }\n else\n format.html { render :edit }\n format.json { render json: @tag_record.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_tag_params(tag)\n new_params = params.dup\n new_params[:t] = {tag => '✓'}\n new_params\n end",
"def update!(**args)\n @xtags = args[:xtags] if args.key?(:xtags)\n end",
"def update!(**args)\n @xtags = args[:xtags] if args.key?(:xtags)\n end"
] |
[
"0.70100665",
"0.67962426",
"0.67500234",
"0.67500234",
"0.67167956",
"0.66967404",
"0.66706336",
"0.6635702",
"0.6629786",
"0.66270185",
"0.65346444",
"0.65046",
"0.6500159",
"0.6496419",
"0.64748824",
"0.64666843",
"0.6454377",
"0.64531195",
"0.6418324",
"0.6418135",
"0.6416457",
"0.6405953",
"0.6368989",
"0.63168126",
"0.6297815",
"0.6296569",
"0.6272881",
"0.62706804",
"0.62651247",
"0.62527835",
"0.62438774",
"0.6239763",
"0.6229065",
"0.6209095",
"0.6194665",
"0.6180149",
"0.6177847",
"0.61739427",
"0.6167976",
"0.61652344",
"0.613534",
"0.61173743",
"0.60980654",
"0.6082397",
"0.60707855",
"0.60619575",
"0.6057254",
"0.6012769",
"0.6004133",
"0.6004007",
"0.60036325",
"0.60006815",
"0.6000351",
"0.5989168",
"0.59861463",
"0.59729",
"0.5972268",
"0.59591776",
"0.595263",
"0.5942992",
"0.59163815",
"0.5914414",
"0.5909743",
"0.58990985",
"0.5893562",
"0.5889776",
"0.5884962",
"0.5884539",
"0.5873196",
"0.58675367",
"0.58386093",
"0.58366615",
"0.5824421",
"0.5815222",
"0.5813106",
"0.5805118",
"0.5796718",
"0.5793371",
"0.57877636",
"0.57829255",
"0.5782282",
"0.577818",
"0.57636404",
"0.57618034",
"0.5760249",
"0.5753774",
"0.5751083",
"0.57482326",
"0.5746246",
"0.5744691",
"0.5742974",
"0.5726225",
"0.57252413",
"0.57226616",
"0.57174677",
"0.57129204",
"0.5708771",
"0.5707787",
"0.57056546",
"0.57056546"
] |
0.75297046
|
0
|
POST /messages POST /messages.json
|
def create
MailerWorker.perform_async(message_params)
flash[:notice] = "Message sent! Thank you for contacting us."
redirect_to root_url
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def post(content)\n post_to(\"/api/v1/messages/\", {:body => content})\n end",
"def create\n message = Message.new(message_params)\n message.message = params[:message_text]\n message.display_name = params[:display_name]\n message.save!\n render json: message\n end",
"def create\n @message = Message.new(message_params)\n\n if @message.save\n render json: @message, status: :created, location: [:api, @message]\n else\n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(message_params)\n\n if @message.save\n @user = User.find(@message.user_id)\n @user.messages << @message\n render json: @message, status: :created\n else\n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(message_params)\n\n if @message.save\n render json: @message, status: :created, location: @message\n else\n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(message_params)\n\n if @message.save\n render json: @message, status: :created, location: @message\n else \n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to new_message_url, notice: t(\"messages.created\") }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n message = Message.new(message_params)\n message.messager = current_user\n\n if message.valid?\n message.save!\n render json: MessageSerializer.new(message).serialize\n else\n render json: { errors: message.errors.messages }, status: 422\n end\n end",
"def create\n\n @message = current_user.messages.new(message_params)\n\n if @message\n respond_to do |format|\n if @message.save\n # debugger\n format.html do\n redirect_to @message, notice: 'Message was successfully created.'\n end\n format.json { render :_message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def create\n @message = Message.new(params[:message])\n @message.user_id = current_user.id\n \n respond_to do |format|\n if @message.save\n format.json { render json: @message, status: :created}\n else\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def message(user, text)\n post('/direct_messages/new.json', :user => user, :text => text)\n end",
"def message(user, text)\n post('/direct_messages/new.json', :user => user, :text => text)\n end",
"def create\n @message = Message.new(message_params)\n respond_to do |format|\n if @message.save\n format.json {render json: :created}\n else\n format.json {render json: \"not created\"}\n end\n end\n end",
"def create_message(user_id, recipient_id, token , subject, message)\n response = self.class.post('/messages', body: { \"user_id\": user_id, \"recipient_id\": recipient_id,\"token\": token , \"subject\": subject, \"stripped-text\": message }, headers: { \"authorization\" => @auth_token })\n puts response\n\n end",
"def create\n @message = Message.new(params[:message])\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message: params[:message_content], from_id: current_user.id, to_id: params[:to_id])\n respond_to do |format|\n if @message.save\n format.html { redirect_to user_path(@message.to_id), notice: 'Message was successfully sent.' }\n else\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(post_params)\n respond_to do |format|\n if @message.save\n flash[:success] = \"문자가 성공적으로 업로드 되었습니다.\"\n format.html { render :show}\n else\n flash[:error] = \"부족한 곳을 채워주세요\"\n format.html { render :new}\n format.json { render json: @message.errors }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message crée avec succès.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n\n end",
"def create\n @message = @conversation.messages.build(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to conversation_messages_path(@conversation), notice: 'メッセージを送信しました。' }\n format.json { render :show, status: :created, location: conversation_messages_path(@conversation) }\n else\n format.html { render :index }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n @message.sent_at = Time.now\n if @message.save\n render text: 'message successfully created.', status: :created\n else\n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(message_params)\n \n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully sent.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @room = Room.find_or_create_by(room_params)\n @message = @room.messages.new(message_params)\n\n if @message.save\n render json: @message, status: :created, location: [@room, @message]\n else\n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def send\n inf = params.permit(:to, :from, :time, :priority, :message, :til)\n message = Message.new\n message.user = current_user\n message.entered = DateTime.now.in_time_zone\n message.year = DateTime.now.in_time_zone.year\n\n message.to = inf[:to]\n message.from = inf[:from]\n message.message_time = inf[:time]\n message.priority = inf[:priority]\n message.message = inf[:message]\n message.til = inf[:til]\n\n unless message.save\n render json: {message: @message.errors}.to_json, \\\n status: :unprocessable_entity\n end\n\n render json: {message: 'Success'}.to_json, status: 200\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n user = User.find_by(token: params[:token])\n new_message_params = {\n text: message_params[:text],\n conversation_id: message_params[:conversation_id],\n user_id: user.id,\n username: user.username\n }\n @message = Message.new(new_message_params)\n conversation = Conversation.find(message_params[:conversation_id])\n\n if @message.save\n # render json: @message, status: :created, location: @message\n serialized_data = ActiveModelSerializers::Adapter::Json.new(\n MessageSerializer.new(@message)\n ).serializable_hash\n MessagesChannel.broadcast_to conversation, serialized_data\n head :ok\n else\n render json: @message.errors, status: :unprocessable_entity\n end\n end",
"def message(message)\n render json: {\n message: message,\n status: :success\n }, status: 200\n end",
"def create\n mesg = Message.new({user_id: @current_user.id, receiver_id: params[:receiver_id], content: params[:content], request_id: params[:request_id]})\n if mesg.save\n render json: {\n status: 'success',\n message: 'Your message was sent',\n data: mesg,\n },\n status: :created\n else\n render json: {\n status: 'error',\n message: 'Message not sent',\n data: mesg.errors\n },\n status: :unprocessable_entity\n end\n end",
"def post_message(token, channel, text, username)\n uri = URI.parse(URL[\"post_msg\"])\n params = { :token => token,\n :channel => channel,\n :text => text,\n :username => username,\n :as_user => true }\n uri.query = URI.encode_www_form( params )\n return JSON.parse( uri.open.read )\n end",
"def post(message)\n puts message\n end",
"def create\n @message = Message.new(message_params)\n\n if @message.save\n render json: { \"status\": \"success\" }, status: 200\n else\n render json: {}, status: 401\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: \"Message sent to #{@message.receiver.full_name}.\" }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = @app_thread.messages.new(message_params)\n @message.user_id = @user.id\n\n respond_to do |format|\n if @message.save\n format.js {}\n format.html { redirect_to user_project_app_thread_url(@user, @project, @app_thread), notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { redirect_to user_project_app_thread_url(@user, @project, @app_thread), notice: @message.errors.full_messages.inspect }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render action: 'show', status: :created, location: @message }\n else\n format.html { render action: 'new' }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to admin_message_path(@message), notice: 'Message was successfully created.' }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_message(text)\n body ={\n \"title\" => @from_name,\n \"picture\" => @from_picture,\n \"message\" => text\n }\n\n self.class.post(room_path, request_options(body))\n end",
"def api_create\n @message = Message.new\n @message.user_id = params[:message][:user_id]\n @message.room_id = params[:message][:room_id]\n @message.content = params[:message][:content]\n @message.save\n\n #Generate de js to publish\n jsScript = createMessage(@message)\n PrivatePub.publish_to(\"/rooms/#{@message.room_id}\", jsScript)\n\n respond_to do |format|\n if @message.update_attributes(params[:message])\n format.json { render json: @message}\n else\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @conversation = Conversation.find(params[:conversation_id])\n if @conversation.messages.create(sender: current_user,\n content: params[:message][:content])\n redirect_to @conversation\n else\n flash[:error] = \"A problem occured\"\n redirect_to @conversation\n end\n #respond_to do |format|\n # format.js { render json: @message }\n # format.html { redirect_back_or_to :back }\n #end\n end",
"def create\n @message = Message.new(message_params)\n @message.sender_id = current_user.id\n @message.recipient_id = params[:recipient_id]\n\n respond_to do |format|\n if @message.save\n flash[:notice] = \"Mesaj gönderildi.\"\n format.json { render json: {success: true} } \n # Pusher.trigger('private-'+params[:recipient_id],'new_message', {:from => current_user.name, \n # :subject => @message.subject})\n else\n flash[:error] = \"Mesaj gönderilemedi.\"\n redirect_to '/'\n end\n end\n end",
"def create\n @message = @ride_request.messages.new(message_params)\n @message.user = current_user\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to :back, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :back }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @user_message = UserMessage.new(user_message_params)\n\n if @user_message.save\n render :show, status: :created, location: @user_message\n else\n render json: @user_message.errors, status: :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(params[:message])\n @status = if @message.save then\n @message \n else\n render :json=> @message, :status=> :unprocessable_entity\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to url_for(action: 'index'), notice: f(@message) }\n format.json { render :show, status: :created, location: url_for(action: 'show', id: @message) }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(message)\n puts message\n end",
"def create\n\t\t@message = Message.create!(params[:message])\n\t\trespond_to do |format|\n\t\t\tformat.js\n\t\tend\n\tend",
"def new\n @message = Message.new\n\n render json: @message\n end",
"def post_message(params)\n self.class.post('/chat.postMessage', body: params.merge({token: @token})).tap do |response|\n raise \"error posting message: #{response.fetch('error', 'unknown error')}\" unless response['ok']\n end\n end",
"def create\n @message = Message.new(message_params)\n @message.user = current_user\n respond_to do |format|\n if @message.save\n format.html { redirect_to root_path, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to user_url(@message.user_id), notice: 'Message was successfully created.' }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n @message.user_sent_id = current_user.id\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :text => '{\"message\": \"Your messages has been sent\"}' }\n #format.json { render action: 'show', status: :created, location: @message }\n else\n format.html { render action: 'new' }\n format.json { render text: 'message'}\n end\n end\n end",
"def create\n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.save\n\n format.html { redirect_to outbox_path, notice: 'Message was successfully created.' }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_messages!(hash)\n Net::HTTP.post_form(URI.parse(@target), {'data'=>hash.to_json})\n end",
"def message(session, message, options={})\n json_request \"message\", {:session => session,\n :message => message}, options\n end",
"def create\n @message = Message.new(message_params)\n @message.message_type = 'Reqular Message `'\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new params[:message]\n @message.save\n respond_with @message, location: after_send_path, notice: t('hyalin.messages.sent_success')\n end",
"def new\n @message = current_user.messages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def create\n \n @message = current_user.messages.build(params[:message])\n if @message.save\n \n \n @account_sid = 'ACdb43c99b5deb7d4ed12083140f41bab3'\n @auth_token = '11dbb8cbba9b004652469aa77e51183c'\n\n # set up a client to talk to the Twilio REST API\n @client = Twilio::REST::Client.new(@account_sid, @auth_token)\n ha = HashWithIndifferentAccess.new(params[:message])\n mssg = ha['content']\n\n friends = {\n \"+14159006499\" => \"Jered\",\n \"+11111111111\" => \"Chris\",\n \"+11111111111\" => \"Kathryn\"}\n\n @account = @client.account\n @message = @account.sms.messages.create({:to => '+14159006499', :from => '+18319204556', :body => mssg})\n puts @message\n flash[:success] = \"Message created!\"\n redirect_to 'http://www.bugl.co/acknowledge.html'\n\n else\n @feed_items = []\n render 'static_pages/home'\n end\n \n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.save\n \n format.json { render json: @message, status: :created, location: @message }\n else\n \n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def messages\n get_json('messages.json')\n end",
"def create\n @room_message = RoomMessage.new(params[:room_message])\n\n respond_to do |format|\n if @room_message.save\n format.html { redirect_to @room_message, notice: 'Room message was successfully created.' }\n format.json { render json: @room_message, status: :created, location: @room_message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @room_message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @text_message = TextMessage.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @text_message }\n end\n end",
"def create\n @message = Message.new sender_id: current_user.id, recipient_id: message_params[:recipient_id], verb: message_params[:verb]\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n puts params['msg']\n receiver = User.find_by(username: params['receiver']).id\n\n @message = Message.new(seen: 0, sender: current_user.id, receiver: receiver, contents: params[:msg], sent_at: Time.now)\n @message.save!\n\n #Load the messages\n m = current_user.chat_with(params['receiver'])\n respond_to do |format|\n format.js { render json: m.to_json }\n format.html\n end\n\n # @message = Message.new(message_params)\n\n # respond_to do |format|\n # if @message.save\n # format.html { redirect_to @message, notice: 'Message was successfully created.' }\n # format.json { render :show, status: :created, location: @message }\n # else\n # format.html { render :new }\n # format.json { render json: @message.errors, status: :unprocessable_entity }\n # end\n # end\n end",
"def post_message(params)\n self.class.post('/chat.postMessage', body: params.merge({token: @token})).tap do |response|\n raise \"error posting message: #{response.fetch('error', 'unknown error')}\" unless response['ok']\n end\n end",
"def create\n @message = Message.new(params[:message])\n\n respond_to do |format|\n if @message.deliver\n format.html { render :thank_you }\n format.json { render json: @message, status: :created, location: @message }\n else\n format.html { render action: \"new\" }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def typer(session, message, options={})\n json_request \"message\", {:session => session,\n :message => message}, options\n end",
"def create\n @message = Message.new\n @message.create_one!(params[:message])\n #Juggernaut.publish(1, parse_chat_message(params[:message][:message], current_user))\n respond_to do |format|\n format.html { redirect_to :index }\n format.js\n end\n end",
"def create\n @msg = Msg.new(msg_params)\n\n respond_to do |format|\n if @msg.save\n format.html { redirect_to @msg, notice: 'Msg was successfully created.' }\n format.json { render action: 'show', status: :created, location: @msg }\n else\n format.html { render action: 'new' }\n format.json { render json: @msg.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n create_message(params)\n end",
"def send_messages\n if Message.send_messages()\n render json: {status: :ok}\n else\n render json: \"Error\"\n end\n end",
"def post(request, _params)\n formatter = WeChatMessageFormatter.new\n message = formatter.parse_incoming_message(request.body.read.to_s)\n # Parse the WeChat message XML format\n\n if message['valid']\n # Queue the message for delayed processing\n @db_manager.store_message(message)\n\n # WeChat always requires incoming user messages to be acknowledged at\n # least with an empty string (empty strings are not shown to users),\n # see: https://chatbotsmagazine.com/building-chatbots-for-wechat-part-1-dba8f160349\n # In this sample app, we simulate a \"Customer Service\"-like scenario\n # providing an instant reply to the user, announcing that a complete\n # reply will follow.\n reply = \"Thank you for your message. We will get back to you as soon as possible!\"\n return formatter.format_instant_reply(message, reply)\n end\n\n return 'Message was sent in a wrong format.'\n end",
"def test_create_palindrome_message\n body = {\n \tdata: {\n \t\ttype: 'messages',\n \t\tattributes: {\n \t\t\tcontent: 'racecar'\n \t\t}\n \t}\n }\n\n post '/messages', body.to_json, 'CONTENT_TYPE' => AppConstants::CONTENT_TYPE\n assert last_response.created?\n assert_equal 'application/vnd.api+json', last_response.headers['Content-Type']\n\n response_body = JSON.parse last_response.body\n data = response_body['data']\n\n assert_equal 'messages', data['type']\n assert_equal body[:data][:attributes][:content], data['attributes']['content']\n assert data['attributes']['is_palindrome']\n assert_equal \"localhost:4567/messages/#{data['id']}\", last_response.headers['Location']\n end",
"def send_message\n \tuser = User.find(params[:user_id]);\n \tif user\n \t\tmessage = Conversation.new(user_id: params[:user_id], message_id: params[:message_id], request_id: params[:request_id])\n \t\tif message.save\n \t\t\tconversation = Conversation.find_by(request_id: params[:request_id])\n \t\t\trender json: conversation\n \t\tend\n \telse\n\t\trender json: {error: 'User not found.'}\n \tend\n end",
"def create\n \n @message = Message.new(body: params[:message][:body], sender_id: current_user.id, receiver_id: params[:message][:receiver_id])\n \n #@message = current_user.messages.build(message_params)\n #@message.save\n #respond_with { @message }\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to message_user_path(@message.sender_id, @message.receiver_id), notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @admin_message = Admin::Message.new(admin_message_params)\n\n respond_to do |format|\n if @admin_message.save\n format.html { redirect_to @admin_message, notice: 'Message was successfully created.' }\n format.json { render :show, status: :created, location: @admin_message }\n else\n format.html { render :new }\n format.json { render json: @admin_message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n @message.room = Room.find(params[:room_id])\n @message.user = @current_user\n respond_to do |format|\n if @message.save\n format.html { redirect_to room_message_path(@message.room, @message), notice: 'Message was successfully created.' }\n format.json { render :show, status: :created }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n format.html { redirect_to messages_url, notice: 'Message was successfully created.' }\n else\n format.html { render :new }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n if @message.save\n SharpenAPI.send_sms(@message.message, @message.recipient_numbers)\n redirect_to admin_bat_signal_path, notice: 'Message was successfully sent'\n else\n format.html { render :new }\n format.json do\n render json: @message.errors, status: :unprocessable_entity\n end\n end\n end",
"def create\n message_params = params[:message]\n message_params[:text] = params[:text]\n message = Message.new(\n author_id: current_user.id,\n chat: Chat.find(message_params[:chat_id]),\n parse_mode: message_params[:parse_mode],\n text: (message_params[:text].join \"\\r\\n\\r\\n\")\n )\n message.image = message_params[:image] if message_params[:image].present?\n puts JSON.pretty_generate message.as_json\n message.save!\n redirect_to admin_message_path(message), notice: 'A message has been created'\n # Message.create!(\n # author_id: current_user.id,\n # chat: Chat.find(message_params[:chat_id]),\n # image: message_params[:image],\n # parse_mode: message_params[:parse_mode],\n # text: (message_params[:text].join \"\\r\\n\\r\\n\")\n # )\n end",
"def new\n @message = Message.new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def new\n @message = Message.new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def create\n inbound_messages.each(&:save)\n render :nothing => true, :status => 200\n end",
"def create\n to = params[:to]\n\n unless to\n raise IOError, \"Incorrect params for sending text message\" \n end\n\n @client = Twilio::REST::Client.new(\n CONFIG[:twilio_account_sid],\n CONFIG[:twilio_auth_token])\n\n @account = @client.account\n @message = @account.sms.messages.create({\n :from => CONFIG[:twilio_phone_number],\n :to => to,\n :body => \"Happy Mining! #{CONFIG[:ios_app_link]}\"}) \n\n rescue => ex\n handle_exception(ex)\n ensure\n respond_to do |format|\n format.json\n end\n end",
"def create\n @message = Message.new(message_params) \n if params.has_key?(:message) and params[:message].has_key?(:users)\n @mu = params[:message][:user].map{ |mu| sg.to_i } - [0]\n end \n if @message.save\n if @mu.kind_of?(Array)\n @message.message_users.delete_all\n @mu.each do |mu_id|\n MessegerUser.create(user_id: mu_id.to_i, message: @message)\n end\n end\n end\n \n\n respond_to do |format|\n if @message.save\n format.html { redirect_to @message, notice: 'Сообщение было успешно создано.' }\n format.json { render :show, status: :created, location: @message }\n else\n format.html { render :new }\n format.json { render json: @message.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @message = Message.new(message_params)\n\n respond_to do |format|\n if @message.save\n # Tell the UserMailer to send a welcome email after save\n MessageMailer.welcome_email(@message).deliver_now\n\n format.html { redirect_to(root_url, :notice => 'Message was successfully sent.') }\n format.json { render json: @message, status: :created, location: @message }\n else\n flash.now.alert = \"Please fill all fields.\"\n # format.html { render action: 'new' }\n # format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @message = Message.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def new\n @message = Message.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def new\n @message = Message.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def new\n @message = Message.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def new\n @message = Message.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end",
"def new\n @message = Message.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @message }\n end\n end"
] |
[
"0.7465386",
"0.71694404",
"0.7112854",
"0.7095524",
"0.70685273",
"0.70200527",
"0.69382447",
"0.6844289",
"0.683413",
"0.683015",
"0.68281627",
"0.68281627",
"0.6783851",
"0.6763146",
"0.67002374",
"0.6698929",
"0.66701055",
"0.66322166",
"0.66246116",
"0.6623654",
"0.6613094",
"0.66087025",
"0.66064614",
"0.65974814",
"0.65929735",
"0.6586782",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6583194",
"0.6580122",
"0.65786195",
"0.6563439",
"0.6561293",
"0.65548825",
"0.6547267",
"0.65393007",
"0.652263",
"0.6520578",
"0.65172887",
"0.65168685",
"0.65026635",
"0.64886004",
"0.6486658",
"0.64856094",
"0.64639294",
"0.6456334",
"0.64554983",
"0.64546174",
"0.64309764",
"0.6425515",
"0.64214706",
"0.6404915",
"0.64044404",
"0.6388286",
"0.63826376",
"0.6382194",
"0.6380992",
"0.63743335",
"0.636351",
"0.6362325",
"0.6355248",
"0.633311",
"0.63263345",
"0.6326246",
"0.63214594",
"0.6311168",
"0.6308262",
"0.6302277",
"0.6293201",
"0.6289386",
"0.62869877",
"0.6284174",
"0.628026",
"0.6272262",
"0.6271469",
"0.6256184",
"0.6255775",
"0.62544894",
"0.6227389",
"0.6225662",
"0.62165046",
"0.6208265",
"0.62042105",
"0.62042105",
"0.6203562",
"0.6201395",
"0.6198471",
"0.61947614",
"0.619097",
"0.619097",
"0.619097",
"0.619097",
"0.619097",
"0.619097"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def message_params
params.require(:message).permit(:name, :email, :message)
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 strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \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 strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\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 model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"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 filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\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 reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\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 url_whitelist; 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 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 sensitive_params=(params)\n @sensitive_params = params\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\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 maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\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 backend_user_params\n params.permit!\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\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 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",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] |
[
"0.6981537",
"0.67835593",
"0.6748275",
"0.67436063",
"0.6736311",
"0.65937173",
"0.6503359",
"0.6498499",
"0.6482832",
"0.6478776",
"0.645703",
"0.6439998",
"0.63802195",
"0.6377008",
"0.6366287",
"0.632018",
"0.63016284",
"0.63011277",
"0.62932974",
"0.62919617",
"0.62905645",
"0.6289235",
"0.6283876",
"0.62425834",
"0.62410337",
"0.6218672",
"0.62151134",
"0.62096137",
"0.6192354",
"0.6178057",
"0.6177618",
"0.61727077",
"0.6162073",
"0.6152049",
"0.61515594",
"0.61458135",
"0.6122875",
"0.61165285",
"0.6107696",
"0.6104097",
"0.6091097",
"0.6080201",
"0.60699946",
"0.6063739",
"0.60206395",
"0.60169303",
"0.60134894",
"0.601003",
"0.6007347",
"0.6007347",
"0.6001054",
"0.59997267",
"0.5997844",
"0.5991826",
"0.5991213",
"0.59911627",
"0.5980111",
"0.5967009",
"0.59597385",
"0.5958542",
"0.595787",
"0.5957425",
"0.59522784",
"0.5951228",
"0.59423685",
"0.5939385",
"0.5939122",
"0.5939122",
"0.59325653",
"0.5930178",
"0.59248054",
"0.59243476",
"0.59164625",
"0.59106",
"0.59101933",
"0.59084356",
"0.5905666",
"0.58975077",
"0.58974737",
"0.5895128",
"0.58946574",
"0.589308",
"0.58916",
"0.5885987",
"0.58838505",
"0.58792",
"0.58723736",
"0.58684355",
"0.58677715",
"0.5865701",
"0.5865538",
"0.5865288",
"0.586385",
"0.5862139",
"0.58614355",
"0.58593005",
"0.5857459",
"0.58541363",
"0.58536613",
"0.58520085",
"0.585011"
] |
0.0
|
-1
|
The model's fullyqualified and quoted primary key.
|
def primary_key
"#{quoted_table_name}.#{model_class.send :primary_key}"
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def primary_key\n '_id'\n end",
"def full_primary_key(klass)\n \"#{klass.quoted_table_name}.#{klass.quoted_primary_key}\"\n end",
"def primary_key\n 'id'\n end",
"def primary_key\n @primary_key ||= @klass.primary_key.to_s\n end",
"def quoted_primary_key\n @quoted_primary_key ||= connection.quote_column_name(primary_key)\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\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_attribute\n :id\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 default_primary_key\n model_name.foreign_key.to_s\n end",
"def primary_key\n self[:primary_key]\n end",
"def primary_key\n @primary_key\n end",
"def primary_key\n self[:primary_key] ||= self[:model].primary_key\n end",
"def orchestrate_primary_key\n 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 ||= :id\n end",
"def primary_key\n @attributes[self.primary_key_attribute]\n end",
"def primary_key=(value)\n @primary_key = value && value.to_s\n @quoted_primary_key = nil\n end",
"def primary_key(table_name)\n 'id' # table.primary_key || 'id'\n end",
"def id_key_for(model_class)\n get_key('ID_KEY', model_class) + '_id'\n end",
"def default_key\n :\"#{underscore(demodulize(self[:model].name))}_id\"\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_name\n @primary_key_name ||= @connection.schema[@table_name.to_s][:primary_key]\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 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 primary_key_type\n \"integer 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 default_key\n :\"#{self[:model].name.to_s.demodulize.underscore}_id\"\n end",
"def id\n attributes[self.class.primary_key]\n end",
"def primary_key\n @resource_options.fetch :primary_key, :\"#{singular_resource_name}_id\"\n end",
"def key\n raise MissingID if not defined?(@id)\n model.key[id]\n end",
"def primary_key_string\n key_attributes.join(' ').parameterize\n end",
"def to_param\n self.primary_key\n end",
"def key\n get_primary_key_value_map[self.class.table_name]\n end",
"def autoincrementing_primary_key\n primary_key\n end",
"def autoincrementing_primary_key\n primary_key\n end",
"def primary_key_value(obj)\n obj.pk\n end",
"def association_primary_key(klass = nil)\n active_record.primary_key\n end",
"def model_identifier\n raise 'Invalid' unless id\n \"#{self.class.name}##{id}\"\n end",
"def original_primary_key\n if sourceRD.naturalKey == \"id\"\n \"original_id\"\n else\n sourceRD.naturalKey\n end\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 id\n model.id.to_s\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_value\n send(self.class.primary_key)\n end",
"def key\n stores_foreign_key? ? foreign_key : primary_key\n end",
"def eol_pk\n \"R#{resource_id}-PK#{id}\"\n end",
"def quoted_id\n id\n end",
"def qualified_primary_key\n cached_fetch(:qualified_primary_key){qualify_cur(primary_key)}\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 scaffold_primary_key\n get_key_array_safe(key).name\n end",
"def identifier\n @identifier ||= \"#{self.type_prefix}.#{Model::to_id @schema.title}.#{Model::to_id name}\"\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_for_sphinx\n @primary_key_for_sphinx ||= read_attribute(self.class.primary_key_for_sphinx)\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 model_id(model)\n \"#{model.class.name}_#{model.id}\"\n end",
"def model_id(model)\n \"#{model.class.name}_#{model.id}\"\n end",
"def id_for_update\n { self.class.primary_key.to_s => __id }\n end",
"def model_id\n model.id\n end",
"def primary_key\n fail NotImplementedError\n end",
"def id\n raise MissingPrimaryKey\n end",
"def pk_hash\n model.primary_key_hash(pk)\n end",
"def default_left_key\n :\"#{underscore(demodulize(self[:model].name))}_id\"\n end",
"def primary_key\n self[:primary_key] ||= associated_class.primary_key\n end",
"def id\n @id ||= self.class.model_name.name.downcase\n end",
"def id\n attr_name = self.class.primary_key\n c = column_for_attribute(attr_name)\n define_read_method(:id, attr_name, c) if self.class.generate_read_methods\n read_attribute(attr_name)\n end",
"def save_primary_key_grip; 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 primary_key(name, type = :primary_key, options = {})\n return super\n end",
"def primary_key(table_name)\n pk_and_sequence_for(table_name)[0]\n rescue\n nil\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(*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 primary_key=(key)\n @primary_key = key\n end",
"def get_id_from_model(model_instance)\n model_instance[foreign_key_column_name]\n end",
"def simple_id\n \"_#{@table.id}_#{@id}\"\n end",
"def primary_key\n fields.select { |f| f.key }.map(&:name)\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 id\n @attributes[\"#{self.class.to_s.split('::').last.underscore.downcase}_id\".to_sym]\n end",
"def pk_field(klass)\n pk = klass.primary_key\n return klass.ann(pk, :field) || pk\n end",
"def default_key\n :\"#{self[:name]}_id\"\n end",
"def default_key\n :\"#{self[:name]}_id\"\n end",
"def default_left_key\n :\"#{self[:model].name.to_s.demodulize.underscore}_id\"\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 key\n id\n end",
"def id\n key\n end",
"def primary_key_constraint_sql_fragment(_)\n 'PRIMARY KEY'\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 foreign_key\n self.name + \"_id\"\n end",
"def primary_key(name, type = :primary_key, options = {})\n return super unless type == :uuid\n options[:default] = options.fetch(:default, 'uuid_generate_v4()')\n options[:primary_key] = true\n column name, type, options\n end",
"def primary_key(name, type = :primary_key, options = {})\n return super unless type == :uuid\n options[:default] = options.fetch(:default, 'uuid_generate_v4()')\n options[:primary_key] = true\n column name, type, options\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 record_id(object)\n #eval \"object.#{object.class.primary_key}\"\n object.id\n end",
"def primary_key(name, type = :primary_key, **options)\n column(name, type, **options.merge(primary_key: true))\n end",
"def association_key_name\n reflection.join_primary_key(klass)\n end",
"def derive_db_id(model_name, obj_id)\n \"#{model_name}_#{obj_id}\"\n end",
"def scaf_foreign_key_name( assoc )\n assoc.primary_key_name\n end"
] |
[
"0.7934944",
"0.7922524",
"0.7919046",
"0.7885284",
"0.7765311",
"0.7662968",
"0.76024866",
"0.75943035",
"0.75943035",
"0.75943035",
"0.7562853",
"0.75185937",
"0.7502828",
"0.74844855",
"0.744577",
"0.74371296",
"0.73982894",
"0.73734903",
"0.73720175",
"0.73550135",
"0.7338632",
"0.7185038",
"0.7175695",
"0.71650755",
"0.71512634",
"0.71503943",
"0.7148735",
"0.71130764",
"0.7038154",
"0.7031055",
"0.7024758",
"0.7021306",
"0.7012847",
"0.700743",
"0.69967276",
"0.69912213",
"0.69544405",
"0.69519424",
"0.69519424",
"0.69404256",
"0.6935097",
"0.6929632",
"0.6915686",
"0.6867992",
"0.68577147",
"0.6849194",
"0.6825415",
"0.6819094",
"0.68148863",
"0.6813606",
"0.67961067",
"0.67880267",
"0.67880267",
"0.67804044",
"0.67761403",
"0.6737665",
"0.6701709",
"0.66968447",
"0.66782326",
"0.66782326",
"0.6666959",
"0.66646004",
"0.6653328",
"0.6651421",
"0.66422254",
"0.6629351",
"0.66143143",
"0.6612257",
"0.6602095",
"0.6600899",
"0.6589752",
"0.6576238",
"0.6573622",
"0.6562899",
"0.65536404",
"0.6544572",
"0.6539772",
"0.6531739",
"0.652959",
"0.65254515",
"0.6513249",
"0.65107983",
"0.65065455",
"0.65056264",
"0.64951694",
"0.6485327",
"0.6481383",
"0.6476729",
"0.64686835",
"0.64570755",
"0.643153",
"0.6423762",
"0.6423762",
"0.64207405",
"0.6418022",
"0.64059246",
"0.639655",
"0.638883",
"0.6387065"
] |
0.8766146
|
1
|
Was the record found using its numeric id?
|
def found_using_numeric_id?
warn("found_using_numeric_id is deprecated and will be removed in 3.0. Please use #friendly_id_status.numeric?")
friendly_id_status.numeric?
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def exists?\n return id.to_s =~ /\\d+/\n end",
"def identified_by?( id )\n\t\t\tself.rpx_identifiers.find_by_identifier( id )\n\t\tend",
"def identified_by?( id )\n\t\t\tself.rpx_identifier == id\n\t\tend",
"def id ; @record.id if @record ; end",
"def found?\n return false if no_search\n\n id.present? || records.present?\n end",
"def find_record(relation = nil)\n if locate_id.nil? || (locate_id.is_a?(::Numeric) && locate_id == 0) || (locate_id.to_s == '')\n return -1\n end\n\n dataset = load_records(relation, false)\n return -1 if dataset.blank?\n\n first_item = dataset.first\n klass = first_item.class\n\n id_field = klass.respond_to?('primary_key') ? klass.primary_key : nil\n id_field ||= first_item.respond_to?('id') ? 'id' : nil\n\n return -1 unless id_field\n if locate_id.is_a?(::Numeric)\n dataset.index{|item| item.send(id_field) == locate_id} || -1\n else\n loc_id = locate_id.to_s.downcase\n dataset.index{|item| item.send(id_field).to_s.downcase == loc_id} || -1\n end\n\n end",
"def find(id); end",
"def find(id); end",
"def object_id?(key)\n @criteria_hash.object_id?(key)\n end",
"def is?(id)\n self.id == id\n end",
"def single_record?\n id.present?\n end",
"def id?\n query_attribute(self.class.primary_key)\n end",
"def find(id)\n # TODO: Find the Contact in the 'contacts.csv' file with the matching id.\n flag = false\n CSV.foreach('contacts.csv') do |csv|\n if id.to_i == csv[0].to_i\n flag = true\n puts csv\n break\n end\n end\n if flag == false\n puts \"Record not found\"\n end\n end",
"def found_using_numeric_id?\n !found_using_friendly_id?\n end",
"def find(id)\r\n find_one do |record|\r\n record.id == id\r\n end\r\n end",
"def include_record?(record_id)\n @records.include?(record_id)\n end",
"def include_record?(record_id)\n @atoms.each do |atomname, atom|\n return true if atom.include_record?(record_id)\n end\n end",
"def cd_in_record?(id)\n @cd_reg_id.include? id\n end",
"def find_record\n record_id = params[:record_id] || params[:id]\n @record = Record.where(medical_record_number: record_id).first\n not_found if @record.nil?\n end",
"def id(num)\n find :id => num\n end",
"def has_record?(record)\n table.has_key?(lookup_key_for(record))\n end",
"def replay_exist?(id)\n id = id.to_s\n exist = @replays.find { |replay| replay[:id] == id }\n exist.nil? ? false : true\n end",
"def find(id)\n self.detect{|x| x.id == id.to_i}\n end",
"def find_by_id(id)\n iterations.find { |iteration| iteration.id == id } || false\n end",
"def record_cached?(id)\n _record_cache.has_key?(id.to_s)\n end",
"def find(x)\n if @candidates.any? {|h| h[:id] == x}\n return @candidates.find {|h| h[:id] == x}\n else\n return \"ID does not exist\".red\n end\nend",
"def exists?(id)\n rec = CONNECTION.execute(\"SELECT * FROM #{table_name} WHERE id = #{id};\").first\n if rec.nil?\n false\n else\n self.new(rec)\n end\n end",
"def at_id(id)\n detect { |title| title.id == id }\n end",
"def id?\n @id\n end",
"def id?(str); end",
"def find(id)\n @records.find { |record| record.id == id }\n end",
"def find_by_id(id)\n self.select { |record| record.id == id.to_s }.first\n end",
"def find_by_id(id)\n self.select { |record| record.id == id.to_s }.first\n end",
"def find (candidate_id)\n @candidates.detect{|candidate| candidate_id == candidate[:id]}\n puts \"No match foud\" if nil \n end",
"def find(id)\n @candidates.detect do |candidate|\n candidate[:id] === id\n end\nend",
"def lookup_id(arg)\n all_by_id[arg]\n end",
"def id\n\t\tif(@tokens[@counter].type == @ID || @tokens[@counter].type == @INT || @tokens[@counter].type == @STRING )\n\t\t\treturn true \n\t\telse \n\t\t\treturn false \n\t\tend \n\tend",
"def record_id(record)\n record.id\n end",
"def exist?(id)\n path = record_path(id)\n File.exist?(path) ? path : nil\n end",
"def find(id)\n find_result\n end",
"def id_found?\n token && decoded_token && decoded_token[:id]\n end",
"def record_identifier(record)\n record.id\n end",
"def row_exists?(unique_identifier)\n wait_for_results\n exists? result_row(unique_identifier)\n end",
"def row_exists?(unique_identifier)\n wait_for_results\n exists? result_row(unique_identifier)\n end",
"def find_by_id(id)\n id = id.to_i\n\n @id_hash[id]\n end",
"def id\n @record.id\n end",
"def find(id)\n end",
"def fetch_uid\n uid = query('id')\n return false unless uid.gsub!(/.*uid=(\\d+).*/, '\\\\1').to_i == 0\n true\n end",
"def exist? (name)\n @by_id[name.to_s]\n end",
"def find(id)\n@candidates.detect {|candidate| candidate[:id] == id}\nend",
"def find(id)\n first(\"Id = '#{id}'\")\n end",
"def exists?\n rec = run_sql(\"SELECT * FROM #{table} WHERE id = #{@id};\")\n if rec.empty?\n @errors << \"That id does not exist in the table.\"\n false\n else\n true\n end\n end",
"def id(data)\n true\n end",
"def contains?(record)\n begin\n val = relation.exists?(record.id)\n @valid = true # set valid to true, if relation.exists?(model) does not throw any exception\n val\n rescue\n @valid = false\n end\n end",
"def show?\n scope.where(:id => record.id).exists?\n end",
"def id\n @record.Id\n end",
"def find_record(table, id)\n result = DB[table].where(id: id).first\n result ? Hashie::Mash.new(result) : nil\nend",
"def id\n @result.check_id\n end",
"def find(id)\n\nreturn candidates.detect{|candidate| candidate[:id]==id }\n\nend",
"def seen_job_with_id?(job_id)\n last_job_id >= job_id\n end",
"def valid?(id)\n store = new\n store.send(:ids).include?(id.to_i)\n end",
"def find(id)\n\nend",
"def record_id\n doc['record_id']\n end",
"def find(id, ignore: [])\n hit = es_get(id, ignore: ignore)\n if hit['found']\n result = instantiate_result(hit)\n return result\n end\n false\n end",
"def find(id)\n sid = id.to_s\n return nil if sid == ''\n return _record_cache[sid] if _record_cache.has_key?(sid) && _class_fetch_states[\"record_#{id}\"] == 'f'\n observer = React::State.current_observer\n record_in_progress = if _record_cache.has_key?(sid)\n _record_cache[sid]\n else\n self.new(id: id)\n end\n record_in_progress_key = \"#{self.to_s}_#{record_in_progress.object_id}\"\n React::State.get_state(observer, record_in_progress_key) if observer\n return _record_cache[sid] if _record_cache.has_key?(sid) && _class_fetch_states[\"record_#{id}\"] == 'i'\n _promise_find(id, record_in_progress).then do\n React::State.set_state(observer, record_in_progress_key, `Date.now() + Math.random()`) if observer\n end\n record_in_progress\n end",
"def exists_with_identity_cache?(id)\n !!fetch_by_id(id)\n end",
"def find_id(id)\n @candidates.find {|candidate| candidate if candidate[:id] == id}\nend",
"def find_record\n record_id = params[:record_id] || params[:id]\n @record = Record.where(medical_record_number: record_id).first\n raise RequestError.new(404) if @record.nil?\n end",
"def id_string(record)\n record && record['001'] && record['001'].value.to_s\n end",
"def exists?(id)\n Stal.solve(redis, [\"SISMEMBER\", key, id]) == 1\n end",
"def id?\n true\n end",
"def is_valid_id id\n\t\tCompany.all.each do |c|\n\t\t\tif c.id == id\n\t\t\t\treturn true\n\t\t\tend\n\t\tend\n\t\treturn false\n \tend",
"def find_record\n @record ||= model.find_by_id(params[:id])\n end",
"def find(id)\n @candidates.detect{|number| number[:id] == id} \n #or option #2\n #def find(id) \n #@candidates.detect{|number| number[:id] == id}\nend",
"def liked_by_user?(id)\n query = self.likes.where(user_id: id).first\n return false unless query.present?\n query.id\n end",
"def find(record_id) \n result = CONNECTION.execute(\"SELECT * FROM #{self.table_name} WHERE id = #{record_id}\").first\n \n self.new(result)\n end",
"def is_stored? (token, id)\n # guard clause for nil token, we just assume there is no entry\n if(token.nil?)\n return false\n end\n # check redis for id\n id_list = @redis.lrange(token, 0, -1)\n id_list.include?(id)\n end",
"def find id\n model.find id\n end",
"def find(id)\n @candidates.detect {|candidates| candidate[:id] == id}\nend",
"def indexed?(obj, index)\n indexes_for(index).map { |i| i[:_id] }.include? obj.id\n end",
"def exist?\n\t\t!self.class.first(:conditions => {:identification_document => identification_document}).nil?\n\tend",
"def id?\n `#@native.isId`\n end",
"def id_from_record(record)\n f907 = record.find {|f| f.tag == \"907\"}\n f907.subfields.find {|s| s.code == \"a\"}.value\nend",
"def match_id?(instance)\n flaggable_flags.where(flaggable_type: instance.class, flaggable_id: instance.id).any?\n end",
"def find_record(item, no_raise: false, meth: nil, **opt)\n # noinspection RubyMismatchedReturnType\n return item if item.nil? || item.is_a?(record_class)\n meth ||= __method__\n record = error = id = nil\n\n id_key = opt.key?(:id_key) ? opt[:id_key] : id_column\n if id_key\n opt.merge!(item) if item.is_a?(Hash)\n opt.reverse_merge!(id_term(item, **opt))\n id = opt[id_key] || opt[alt_id_key(opt)]\n if id && (id_key == id_column)\n record = record_class.find(id)\n error = \"for #{id_key} #{id.inspect}\" unless record\n elsif id\n record = record_class.find_by(id_key => id)\n error = \"for #{id_key} #{id.inspect}\" unless record\n else\n error = \"#{id_key} value given\"\n end\n error &&= \"No #{record_name} #{error}\"\n else\n error = \"#{record_name}: :id_key set to nil\"\n end\n\n if record\n record\n elsif !id\n Log.info { \"#{meth}: #{error} (no record specified)\" }\n raise_failure(:file_id) unless no_raise\n elsif no_raise\n # noinspection RubyMismatchedReturnType\n Log.warn { \"#{meth}: #{error} (skipping)\" }\n else\n Log.error { \"#{meth}: #{error}\" }\n raise_failure(:find, item) unless no_raise\n end\n end",
"def find(record_id)\n result = DATABASE.execute(\"SELECT * FROM #{table} WHERE id = #{record_id}\").first\n\n self.new(result)\n end",
"def find(id)\n @data[id]\n end",
"def ==(object)\n self._id == object._id rescue false\n end",
"def exists?\n model.exists?(@id)\n end",
"def exists?(id)\n !index[id.to_s].nil?\n end",
"def fetch(id)\n search(id: id)[:records].first\n end",
"def test_lookup\n return if test_identifier.blank?\n return if (matches = test_identifier.match(/(\\d+\\b)/)).blank?\n\n encounters = patient ? patient.encounters : Encounter\n self.encounter = encounters.where(is_phantom: false, institution_id: institution_id)\n .find_by(id: matches[0].to_i)\n end",
"def exists?(classname, id)\n #Make sure the given data are in the correct types.\n classname = classname.to_sym\n id = id.to_i\n\n #Check if ID-cache is enabled for that classname. Avoid SQL-lookup by using that.\n if @ids_cache_should.key?(classname)\n if @ids_cache[classname].key?(id)\n return true\n else\n return false\n end\n end\n\n #If the object currently exists in cache, we dont have to do a lookup either.\n return true if @objects.key?(classname) and obj = @objects[classname].get!(id) and !obj.deleted?\n\n #Okay - no other options than to actually do a real lookup.\n begin\n table = @args[:module].const_get(classname).table\n row = @args[:db].single(table, {@args[:col_id] => id})\n\n if row\n return true\n else\n return false\n end\n rescue Errno::ENOENT\n return false\n end\n end",
"def is_id?(key)\n key =~ /^[A-Z0-9]+$/\n end",
"def find(id)\n\t@candidates.detect { |candidate| candidate[:id] == id }\nend",
"def acceptable_id?\n id = extracted_id\n existing._id == id || id.nil? || (existing._id != id && update_only?)\n end",
"def find_from!(collection, identifier, find_by = :id)\n if identifier.present?\n collection.detect { |instance| instance.send(find_by) == identifier.to_i } || (raise ActiveRecord::RecordNotFound)\n else\n raise ActiveRecord::RecordNotFound\n end\n end",
"def include?(record)\n # The existing implementation relies on receiving an Active Record instance as the input parameter named record.\n # Any non-Active Record object passed to this implementation is guaranteed to return `false`.\n return false unless record.is_a?(klass)\n\n if loaded? || offset_value || limit_value || having_clause.any?\n records.include?(record)\n else\n id = if record.class.composite_primary_key?\n record.class.primary_key.zip(record.id).to_h\n else\n record.id\n end\n\n exists?(id)\n end\n end",
"def found?\n\t\t\t!!@found\n\t\tend",
"def exists\n @record = Record.new\n comment = Comment.find_by_app_id_and_authorId(params[:app_id], params[:authorId], :select => :id)\n\n if comment.nil?\n @record.exists = false\n else\n @record.id = comment.id\n @record.exists = true\n end\n\n respond_to do |format|\n format.xml {render :xml => @record}\n format.json {render :json => @record} \n end\n end",
"def find(record_id)\n # Figure out the table's name from the class we're calling the method on.\n table_name = self.to_s.pluralize.underscore\n \n results= CONNECTION.execute(\"SELECT * FROM #{table_name} WHERE id = #{record_id}\")\n if results.empty? \n return nil\n else \n result=results.first\n self.new(result)\n end\n end"
] |
[
"0.69426155",
"0.6898101",
"0.6883071",
"0.68743175",
"0.6844176",
"0.6688446",
"0.66270024",
"0.66270024",
"0.64962536",
"0.64956",
"0.6492035",
"0.6487673",
"0.6454233",
"0.64452815",
"0.6439379",
"0.6438676",
"0.6409589",
"0.6340384",
"0.63345164",
"0.63328314",
"0.6317044",
"0.6305617",
"0.62714493",
"0.6217003",
"0.62062156",
"0.6174425",
"0.6146076",
"0.61323744",
"0.61304075",
"0.612779",
"0.61165535",
"0.6115509",
"0.6115509",
"0.6107506",
"0.61034703",
"0.6101348",
"0.6094976",
"0.6056425",
"0.60348094",
"0.6029884",
"0.6025675",
"0.60226536",
"0.6019405",
"0.6019405",
"0.60186493",
"0.60131687",
"0.5982919",
"0.59770536",
"0.597171",
"0.59700704",
"0.5961777",
"0.59522885",
"0.5940835",
"0.59375423",
"0.59350234",
"0.5931486",
"0.5922214",
"0.5907597",
"0.5905299",
"0.5903071",
"0.5893823",
"0.5888291",
"0.5885622",
"0.58699304",
"0.5867914",
"0.5867746",
"0.5862083",
"0.5860496",
"0.5858432",
"0.5854513",
"0.5852791",
"0.58526355",
"0.58492106",
"0.5849072",
"0.5847082",
"0.5845804",
"0.58421737",
"0.58389264",
"0.5835537",
"0.58315176",
"0.5810866",
"0.58101153",
"0.58075833",
"0.5800187",
"0.5795699",
"0.57866824",
"0.57813406",
"0.57769305",
"0.57693654",
"0.57684046",
"0.5762712",
"0.5761421",
"0.5760273",
"0.57594144",
"0.574859",
"0.5741894",
"0.57414424",
"0.57407737",
"0.57306397",
"0.572086",
"0.5716276"
] |
0.0
|
-1
|
Was the record found using an old friendly id, or its numeric id?
|
def has_better_id?
warn("has_better_id? is deprecated and will be removed in 3.0. Please use !#friendly_id_status.best?")
! friendly_id_status.best?
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def found_using_numeric_id?\n !found_using_friendly_id?\n end",
"def has_better_id?\n slug and found_using_numeric_id? || found_using_outdated_friendly_id?\n end",
"def found_using_outdated_friendly_id?\n finder_slug.id != slug.id\n end",
"def acceptable_id?\n id = extracted_id\n existing._id == id || id.nil? || (existing._id != id && update_only?)\n end",
"def found_using_numeric_id?\n warn(\"found_using_numeric_id is deprecated and will be removed in 3.0. Please use #friendly_id_status.numeric?\")\n friendly_id_status.numeric?\n end",
"def stable_id?\n false\n end",
"def id_changed?\n to_id != @attributes[self.class.id_method]\n end",
"def id?(str); end",
"def known_invalid_idref(mapkey, oldid)\n\treturn false;\n\t# \treturn ( ((mapkey==:version or mapkey==:fixfor) and oldid==21907 or oldid==21881 or oldid==21743) or\n\t# \t\t\t(mapkey==:version and (oldid==21240 or oldid==21743)) or \n\t# \t\t\t(mapkey==:issuestatus and (oldid==2 or oldid==-3)) or\n\t# \t\t\t(mapkey==:resolution and oldid==6)\n\t# \t )\nend",
"def valid_id_number; end",
"def id ; @record.id if @record ; end",
"def identified_by?( id )\n\t\t\tself.rpx_identifier == id\n\t\tend",
"def is_id?(key)\n key =~ /^[A-Z0-9]+$/\n end",
"def should_generate_new_friendly_id?\n\t\t# new_record?\n\t\ttrue\n\tend",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def unfriendly_id?; end",
"def db_id?(key)\n key.is_a?(Fixnum) or key.is_a?(Integer) or key =~ /^[0-9]+$/\n end",
"def should_generate_new_friendly_id?\n new_record?\n end",
"def should_generate_new_friendly_id?\n new_record?\n end",
"def should_generate_new_friendly_id?\n new_record?\n end",
"def exists?\n return id.to_s =~ /\\d+/\n end",
"def invalid_id_number; end",
"def original_identity?\n external_identifier == user_id\n end",
"def should_generate_new_friendly_id?\n new_record? || true\n end",
"def correct_identifier?\n (openid_request.identity == identifier(current_account) || openid_request.id_select)\n end",
"def is?(id)\n self.id == id\n end",
"def find_if_changed(record)\n id, md5sum = id_and_md5sum_for(record)\n return false if md5sum == record.md5sum\n find(id)\n end",
"def legacy_id\n return @legacy_id\n end",
"def mongoid_id?\n to_s =~ /^(|_)id$/\n end",
"def identified_by?( id )\n\t\t\tself.rpx_identifiers.find_by_identifier( id )\n\t\tend",
"def real_id(model_name, friendly_id)\n if friendly_id.to_s.to_i == 0\n obj = model_name.constantize.find(friendly_id)\n if obj\n return obj.id\n end\n end\n friendly_id\n end",
"def should_generate_new_friendly_id?\r\n name_changed? || super\r\n end",
"def id_string(record)\n record && record['001'] && record['001'].value.to_s\n end",
"def id?\n query_attribute(self.class.primary_key)\n end",
"def updatable?\n sir_item.sir_entries.last.id == id\n end",
"def should_generate_new_friendly_id?\n attribute_changed?(title)\n end",
"def id_truncated?\n !@trace_id_upper64.nil?\n end",
"def correct_identifier?\n (openid_request.identity == openid_identifier(current_user) || openid_request.id_select)\n end",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def id_valid?(id)\n return id.between?(1, LAST_ID)\n end",
"def id_valid?(id)\n return id.between?(1, LAST_ID)\n end",
"def new_id(old_id)\n puts \"\\n\\n\\n Redirecting from modernwanderlust post with ID of #{old_id}!\\n\\n\"\n if old_id == \"22\"\n return \"1\"\n elsif old_id == \"21\"\n return \"2\"\n elsif old_id.to_i <= 88\n return (old_id.to_i - 20).to_s\n elsif old_id == \"89\"\n return \"70\"\n elsif old_id == \"90\"\n return \"69\"\n elsif old_id.to_i <= 93\n return (old_id.to_i - 20).to_s\n else \n return (old_id.to_i - 21).to_s\n end\n end",
"def valid_orcid_id?(id)\n if id =~ /[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9,X]{4}/\n id = id.delete('-')\n id[15] == orcid_checksum(id)\n else\n false\n end\n end",
"def should_generate_new_friendly_id?\n self.changes.has_key?(:prefix)\n end",
"def fetch_uid\n uid = query('id')\n return false unless uid.gsub!(/.*uid=(\\d+).*/, '\\\\1').to_i == 0\n true\n end",
"def record_cached?(id)\n _record_cache.has_key?(id.to_s)\n end",
"def alternative_id?(attr_name, access_by: nil)\n attr_name = attr_name.to_sym\n alternative_id_fields(access_by: access_by).include?(attr_name)\n end",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def record_identifier(record)\n record.id\n end",
"def unfriendly_id?\n val = friendly_id?\n !val unless val.nil?\n end",
"def should_generate_new_friendly_id?; end",
"def check_if_valid_link\n @probably_unique_id=params[:id]\n @document=Document.find_by_probably_unique_id(@probably_unique_id) || no_valid_link\n end",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def match_request?(otid)\r\n\t\t\treturn (@orig_tid.to_i == otid.to_i)\r\n\t\tend",
"def should_generate_new_friendly_id?\n\t new_record? || slug.blank?\n\t \n\tend",
"def should_generate_new_friendly_id?\n title_changed?\n end",
"def seen?(ticket, old_cache)\n !old_cache.key?(ticket[:spacekey]) or \n old_cache[ticket[:spacekey]] < ticket[:id]\n end",
"def should_generate_new_friendly_id?\n name_changed? || super\n end",
"def return_id(obj)\r\n if (obj.new_record?)\r\n 'new_rec'\r\n else\r\n obj.id\r\n end\r\n end",
"def primary_id_changed?(primaryVenue)\n return primaryVenue.id != venueId\n end",
"def should_generate_new_friendly_id?\n name_changed? || super\n end",
"def should_generate_new_friendly_id?\n changes.keys.include?(\"title\")\n end",
"def should_generate_new_friendly_id?\n changes.keys.include?(\"title\")\n end",
"def id\n\t\tif(@tokens[@counter].type == @ID || @tokens[@counter].type == @INT || @tokens[@counter].type == @STRING )\n\t\t\treturn true \n\t\telse \n\t\t\treturn false \n\t\tend \n\tend",
"def feed_id\n new_id_format_date = \"2009-11-14\".to_time\n self.created_at < new_id_format_date ? unique_path : id\n end",
"def friendly_id_changes\n changes[friendly_id_config.column.to_s]\n end",
"def friendly_id_changes\n changes[friendly_id_config.column.to_s]\n end",
"def single_record?\n id.present?\n end",
"def should_generate_new_friendly_id?\n\t new_record? || slug.blank?\n\tend",
"def should_generate_new_friendly_id?\n\t new_record? || slug.blank?\n\tend",
"def id?\n @id\n end",
"def should_generate_new_friendly_id?\n list_changed?\n end",
"def id?\n @kind == :id\n end",
"def fresh_record?(id)\n record = find_world(id)\n return false if record.nil?\n @executor[id] = record.data[:class] == 'Dynflow::Coordinator::ExecutorWorld'\n time = self.class.load_time(record.data[:meta][:last_seen])\n time >= Time.now - @max_age\n end",
"def id?\n true\n end",
"def should_generate_new_friendly_id?\n new_record? || self.slug.nil?\n end",
"def ==(object)\n self._id == object._id rescue false\n end",
"def real_id\n @id\n end",
"def real_id\n @id\n end",
"def new_record?\n self.internal_id == nil\n end",
"def different_target?(record)\n record.id != owner._read_attribute(reflection.foreign_key)\n end",
"def bad_slug?(object)\n params[:id] != object.to_param\n end",
"def bad_slug?(object)\n params[:id] != object.to_param\n end",
"def is_valid_id id\n\t\tCompany.all.each do |c|\n\t\t\tif c.id == id\n\t\t\t\treturn true\n\t\t\tend\n\t\tend\n\t\treturn false\n \tend",
"def id_number; end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n new_record? || slug.blank?\n end",
"def should_generate_new_friendly_id?\n datetime_from_exif_changed? ||\n datetime_from_file_changed? ||\n datetime_from_manual_entry_year_changed? ||\n datetime_from_manual_entry_month_changed? ||\n datetime_from_manual_entry_day_changed? ||\n datetime_from_manual_entry_hour_changed? ||\n datetime_from_manual_entry_minute_changed? ||\n datetime_from_manual_entry_second_changed? ||\n source_attachment.changed? ||\n source_catalog_file_path_changed? ||\n source_type_changed? ||\n super\n end",
"def object_id?(key)\n @criteria_hash.object_id?(key)\n end",
"def correct?\n person_id == guessed_person_id\n end",
"def should_generate_new_friendly_id?\n\t name_changed?||self.slug.nil?\n\tend"
] |
[
"0.7403386",
"0.7355705",
"0.6893606",
"0.6605531",
"0.6499431",
"0.63510394",
"0.6240523",
"0.61992705",
"0.61342454",
"0.6091137",
"0.6073619",
"0.60348225",
"0.6003004",
"0.5996063",
"0.5980389",
"0.5980389",
"0.5980389",
"0.5980389",
"0.5980389",
"0.5940632",
"0.5935978",
"0.5901431",
"0.5901431",
"0.5901431",
"0.5891278",
"0.5879765",
"0.58370316",
"0.5824528",
"0.5801841",
"0.57982314",
"0.57720983",
"0.57507145",
"0.5725229",
"0.5712637",
"0.57039505",
"0.5685203",
"0.5681637",
"0.5679618",
"0.5679452",
"0.5672581",
"0.5652559",
"0.564539",
"0.5641859",
"0.56418467",
"0.56418467",
"0.5639181",
"0.56377316",
"0.5630547",
"0.56245816",
"0.56155556",
"0.56091774",
"0.56078017",
"0.56078017",
"0.56078017",
"0.56078017",
"0.5606507",
"0.55994666",
"0.5598051",
"0.55978656",
"0.5594803",
"0.55902886",
"0.5587953",
"0.55832887",
"0.55702347",
"0.55644315",
"0.5563928",
"0.55589956",
"0.5556532",
"0.5538078",
"0.5538078",
"0.553488",
"0.5532589",
"0.5526227",
"0.5526227",
"0.55242896",
"0.5523038",
"0.5523038",
"0.5514272",
"0.5503744",
"0.5501797",
"0.55010784",
"0.5499033",
"0.5492463",
"0.5491444",
"0.549023",
"0.549023",
"0.54862964",
"0.5484448",
"0.5482078",
"0.5482078",
"0.54792005",
"0.5478515",
"0.5478211",
"0.5478211",
"0.5478211",
"0.5478211",
"0.5477652",
"0.5473286",
"0.547168",
"0.5470253"
] |
0.6194821
|
8
|
Returns the friendly id, or if none is available, the numeric id.
|
def to_param
(friendly_id || id).to_s
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def real_id(model_name, friendly_id)\n if friendly_id.to_s.to_i == 0\n obj = model_name.constantize.find(friendly_id)\n if obj\n return obj.id\n end\n end\n friendly_id\n end",
"def actual_id\n args = params[:id].split('-')\n args[0]\n end",
"def id\n raise MissingID if not defined?(@id)\n @id.to_i\n end",
"def get_id(id)\n native_id = Integer(id.split(\":\")[-1])\n end",
"def friendly_id; end",
"def id\n @id || self.class.name.underscore.split('/').last #gsub('/', '_')\n end",
"def friendly_id\n slug(true).to_friendly_id\n end",
"def user_id\n if (id = (@opts[:user_id] || @opts['user_id'])) && id.respond_to?(:to_s)\n if (id = id.to_s).size > 0 && id != '0'\n return id\n end\n end\n end",
"def id\n '1234567890'\n end",
"def numId\n id.to_s.slice(-9,9).hex.to_i\n end",
"def probably_unique_id\n @probably_unique_id||=complete_path.base26_hash\n end",
"def id\n _id rescue nil\n end",
"def has_better_id?\n slug and found_using_numeric_id? || found_using_outdated_friendly_id?\n end",
"def friendly_id\n send friendly_id_config.query_field\n end",
"def registry_id_safe\n @registry_id || '[NO ID]'\n end",
"def get_id\n default_id = self.class.to_s.split('::').last\n default_id[0] = default_id[0].downcase\n return default_id\n end",
"def id\n return @playing_girl ? @id_girl : @id_boy\n end",
"def id\n key?(:id) ? method_missing(:id) : nil\n end",
"def id\n @id ||= \"%x-%s\" % [ Time.now.to_i, SecureRandom::hex(2) ]\n end",
"def short_code\n id.to_s 36\n end",
"def registry_id_safe\n @registry_id || :NO_ID\n end",
"def get_id()\n return @id\n end",
"def unique_id\n object_id.abs.to_s(16)\n end",
"def code\n id ? id.to_s(36) : nil\n end",
"def parse_id(fhir_formulary)\n\t\treturn fhir_formulary.id\n\tend",
"def unfriendly_id?; end",
"def oid\n id(get_oid())\n end",
"def legible_id\n 10 == self.tag_id.length ? \"#{self.tag_id[0..2]}-#{self.tag_id[3..5]}-#{self.tag_id[6..9]}\" : self.tag_id\n end",
"def full_id\n self.id.blank? ? '0000000000' : self.id.to_s.rjust(10,'0')\n end",
"def id(num)\n find :id => num\n end",
"def digitool_id\n return nil if @mods.nil?\n return @mods.digitool_ids.first\n end",
"def unique_identifier\n @u_id ||= \"T1\"\n @u_id = @u_id.succ\n end",
"def get_id()\n return @id\n end",
"def identifier\n best_identifier\n end",
"def goodreads_id\n @url.match(/\\/(\\d+)\\./)[1] rescue nil\n end",
"def get_user_id(user)\n if user.id < 10\n return \"USR0\" + user.id.to_s\n else\n return \"USR\" + user.id.to_s\n end\n end",
"def full_id9\n self.id.blank? ? '000000000' : self.id.to_s.rjust(9,'0')\n end",
"def simple_id\n \"_#{@table.id}_#{@id}\"\n end",
"def field_id(lookup = nil)\n field = field(lookup)\n field[:id].to_i if field\n end",
"def get_id \n part_number = PartNumber.get_part_number(self)\n part_number.id if part_number\n end",
"def public_ID(id = nil)\r\n return id ? id & 0xFFFF : @id & 0xFFFF\r\n end",
"def get_id\n\t\treturn id\n\tend",
"def legacy_id\n return @legacy_id\n end",
"def get_id\n @id ||= 0\n @id += 1\n @id\n end",
"def id_text\n sprintf(\"%03d\", $pokedex.national? ? @id : primary_data.id_bis)\n end",
"def found_using_numeric_id?\n !found_using_friendly_id?\n end",
"def facture_id\n @facture_id ||= data[:id][0..31]\n end",
"def to_param_from_slug\n slug? ? slug.to_friendly_id : id.to_s\n end",
"def to_param_from_slug\n slug? ? slug.to_friendly_id : id.to_s\n end",
"def to_param_from_slug\n slug? ? slug.to_friendly_id : id.to_s\n end",
"def id\n name.gsub /-/, '_'\n end",
"def id\n\t\t@id ||= \"#{page_id.nil? ? 0 : page_id}_#{part}_#{position}\"\n\tend",
"def canonical_id\n @canonical_id ||= crate.resolve_id(id)\n end",
"def get_uid_int\n self.uid.to_i\n end",
"def id(string)\n return if string.blank?\n\n URI(string)\n .path\n .split(\"/\")\n .last\n .to_i\n end",
"def druid \n \n ## Derived, *relatively* unique ID.\n return display_name.strip.downcase.delete \" .,-_'\"\n \n end",
"def id\n \"#{kind}_#{@id}\"\n end",
"def id\n \"#{kind}_#{@id}\"\n end",
"def to_param\n slug ? slug.to_friendly_id : id.to_s\n end",
"def get_id()\n @id\n end",
"def get_id()\n @id\n end",
"def basic_generate_id(str); end",
"def return_id\n\t\treturn @idStr\n\tend",
"def to_param\n if friendly_id_config.routes == :friendly\n friendly_id.presence.to_param || super\n else\n super\n end\n end",
"def fetch_id(char_name)\n char = Character.find_by_name(char_name)\n char.id\n end",
"def id\n \"#{controller.url}/#{name}\"[1..-1].gsub('/', '_')\n end",
"def id\n @id ||= \"#{student.id}-#{lesson_part.id}\"\n end",
"def generate_id()\n return nil unless @name and @represents\n @id ||= Digest::SHA1.hexdigest(@name + @represents)[0..5].force_encoding('utf-8').to_s\n end",
"def get_account_id\n num = rand(111111111..999999999)\n id = sprintf(\"%09d\", num)\n id.to_s\n end",
"def generate_unique_id\n \"1.3.6.1.4.1.21367.2009.5.14.#{id}.#{Time.now.to_i}\"\n end",
"def format_id(id)\n /(\\d+)/.match(id)\n end",
"def new_id\n dbm = self.class.dbm\n\n max = dbm.keys.map { |k| k.to_i }.max || 0\n id = max + 1\n\n dbm[id.to_s] ||= \"\"\n\n id.to_s\n end",
"def id\n name.gsub(':', '-')\n end",
"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 make_id\n \"#{self.class.name.downcase}#{id}\"\n end",
"def unique_id\n to_nil _response_entity.fetch(\"entityEnglishId\", nil)\n end",
"def first_uid()\n max_uid - max_capacity + 1\n end",
"def id\n Id.new(@head.fetch[2])\n end",
"def _id\n @attributes && @attributes[:_id]\n end",
"def unique_id\n id || @generated_dom_id || (@generated_dom_id = Time.now.to_f.to_s.gsub('.', '_'))\n end",
"def identify!\n self.id ||= SecureRandom.uuid\n end",
"def id\n @id_number = 12345\n end",
"def generate_id(str); end",
"def loser_id\n return self.send(\"#{loser}_id\".intern)\n end",
"def valid_id_number; end",
"def id\n get_val(:id)\n end",
"def id\n self._id.to_s if self._id\n end",
"def unique_id\n $unique_id_increment = ($unique_id_increment || 0) + 1\n return (Time.new.to_f * 1000).to_i.to_s + $unique_id_increment.to_s\nend",
"def find_by_friendly_id(id); end",
"def assign_identifier\n self.id ||= SecureRandom.uuid\n end",
"def to_param_from_cache\n attribute_get(friendly_id_config.cache_column) || id.to_s\n end",
"def identifier\n id || name || default_identifier\n end",
"def unique_id\n # Consider using SecureRandom.hex here, and benchmark which one is better\n (Time.now.to_f * 1000).to_i.to_s(36) + rand(1_000_000).to_s(36)\n end",
"def id_lookup(id)\n id = id.to_i\n if (id >= 128) && (id <= 255)\n id = \"oem_data_#{id}\"\n elsif DMI::ID_TO_DESCRIPTION.key?(id)\n id = DMI::ID_TO_DESCRIPTION[id]\n else\n Ohai::Log.debug(\"unrecognized header id; falling back to 'unknown'\")\n id = \"unknown_dmi_id_#{id}\"\n end\n rescue\n Ohai::Log.debug(\"failed to look up id #{id}, returning unchanged\")\n id\n end",
"def get_userid()\n user_info = call_myspace_api(:user_info, :v1_json => true)\n user_info['userId'].to_s\n end",
"def real_id\n @id\n end",
"def real_id\n @id\n end"
] |
[
"0.7531354",
"0.6799069",
"0.67762977",
"0.67061",
"0.6572775",
"0.6477305",
"0.64661443",
"0.64659625",
"0.64579844",
"0.645301",
"0.645075",
"0.6433104",
"0.642394",
"0.6412915",
"0.6345919",
"0.6344134",
"0.6338794",
"0.63315356",
"0.63122684",
"0.6308682",
"0.6297837",
"0.62360334",
"0.62291044",
"0.6211116",
"0.62000793",
"0.6177893",
"0.6162703",
"0.6151042",
"0.61446565",
"0.61433655",
"0.61401284",
"0.61398154",
"0.61273086",
"0.61209023",
"0.61111873",
"0.6108909",
"0.61008525",
"0.60991454",
"0.60956144",
"0.6074277",
"0.6065542",
"0.60542095",
"0.60362566",
"0.6035885",
"0.60352236",
"0.6034238",
"0.6028411",
"0.60255843",
"0.60255843",
"0.60255843",
"0.60188204",
"0.6013146",
"0.60100603",
"0.6008981",
"0.5992561",
"0.59884435",
"0.5988052",
"0.5988052",
"0.5987978",
"0.59855235",
"0.59855235",
"0.59745437",
"0.59740716",
"0.59618336",
"0.59581304",
"0.59572124",
"0.59568053",
"0.5956679",
"0.59563524",
"0.59495324",
"0.5939888",
"0.5939269",
"0.593645",
"0.5929262",
"0.59223855",
"0.5919986",
"0.5913708",
"0.5909436",
"0.59006613",
"0.5898172",
"0.589582",
"0.58945847",
"0.58943146",
"0.5892499",
"0.58924913",
"0.5888545",
"0.58878285",
"0.58819324",
"0.58813727",
"0.58789754",
"0.58767444",
"0.58690923",
"0.5868044",
"0.58620876",
"0.58514977",
"0.5849363",
"0.5849363"
] |
0.65042126
|
8
|
The old and new values for the friendly_id column.
|
def friendly_id_changes
changes[friendly_id_config.column.to_s]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def friendly_id; end",
"def oldid(value)\n merge(oldid: value.to_s)\n end",
"def oldid(value)\n merge(oldid: value.to_s)\n end",
"def history_update\n return if !saved_changes?\n\n # return if it's no update\n return if new_record?\n\n # new record also triggers update, so ignore new records\n changes = saved_changes\n history_changes_last_done&.each do |key, value|\n if changes.key?(key) && changes[key] == value\n changes.delete(key)\n end\n end\n self.history_changes_last_done = changes\n #logger.info 'updated ' + self.changes.inspect\n\n return if changes['id'] && !changes['id'][0]\n\n ignored_attributes = self.class.instance_variable_get(:@history_attributes_ignored) || []\n ignored_attributes += %i[created_at updated_at]\n\n changes.each do |key, value|\n\n next if ignored_attributes.include?(key.to_sym)\n\n # get attribute name\n attribute_name = key.to_s\n if attribute_name[-3, 3] == '_id'\n attribute_name = attribute_name[ 0, attribute_name.length - 3 ]\n end\n\n value_id = []\n value_str = [ value[0], value[1] ]\n if key.to_s[-3, 3] == '_id'\n value_id[0] = value[0]\n value_id[1] = value[1]\n\n if respond_to?(attribute_name) && send(attribute_name)\n relation_class = send(attribute_name).class\n if relation_class && value_id[0]\n relation_model = relation_class.lookup(id: value_id[0])\n if relation_model\n if relation_model['name']\n value_str[0] = relation_model['name']\n elsif relation_model.respond_to?('fullname')\n value_str[0] = relation_model.send('fullname')\n end\n end\n end\n if relation_class && value_id[1]\n relation_model = relation_class.lookup(id: value_id[1])\n if relation_model\n if relation_model['name']\n value_str[1] = relation_model['name']\n elsif relation_model.respond_to?('fullname')\n value_str[1] = relation_model.send('fullname')\n end\n end\n end\n end\n end\n data = {\n history_attribute: attribute_name,\n value_from: value_str[0].to_s,\n value_to: value_str[1].to_s,\n id_from: value_id[0],\n id_to: value_id[1],\n }\n #logger.info \"HIST NEW #{self.class.to_s}.find(#{self.id}) #{data.inspect}\"\n history_log('updated', data)\n end\n end",
"def versioned_attributes_before_last_save\n versioned_columns.map { |attr| [attr, attribute_before_last_save(attr)] }.to_h.with_indifferent_access\n end",
"def legacy_id\n return @legacy_id\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def should_generate_new_friendly_id?\n name_changed?\n end",
"def restore_before_to_new_record_values\n values = @_before_to_new_record_values\n self.id = values[:id]\n self.created_at = values[:created_at] if respond_to?(:updated_at=)\n self.updated_at = values[:updated_at] if respond_to?(:updated_at=)\n end",
"def state_change_to_be_saved\n old, new = super\n\n if old.is_a? Integer\n old = self.class.states.find { |_, int| int == old }.first\n end\n\n [old, new]\n end",
"def changed_attributes\n @_hr_changed.select{|k,v| v}.keys.inject({}) {|h,k| h[k]=self[k]; h}\n end",
"def store_before_to_new_record_values\n values = {:id => id}\n values[:updated_at] = updated_at if respond_to?(:updated_at)\n values[:created_at] = created_at if respond_to?(:created_at)\n @_before_to_new_record_values = values\n end",
"def friendly_id_config; end",
"def should_generate_new_friendly_id?\r\n name_changed? || super\r\n end",
"def attachment_reference_id_changes\n attachment_reference_id_changes = Array.new(2, [])\n self.class.attachable_columns.each do |column|\n old_ids, curr_ids = send(\"#{column}#{ATTACHMENT_CHANGED_SUFFIX}\")\n attachment_reference_id_changes[0] += old_ids if old_ids\n attachment_reference_id_changes[1] += curr_ids if curr_ids\n end\n\n attachment_reference_id_changes\n end",
"def friendly_id\n send friendly_id_config.query_field\n end",
"def should_generate_new_friendly_id?\n name_changed? || super\n end",
"def should_generate_new_friendly_id?\n list_changed?\n end",
"def changed\n changed_attributes.keys\n end",
"def new_id(old_id)\n puts \"\\n\\n\\n Redirecting from modernwanderlust post with ID of #{old_id}!\\n\\n\"\n if old_id == \"22\"\n return \"1\"\n elsif old_id == \"21\"\n return \"2\"\n elsif old_id.to_i <= 88\n return (old_id.to_i - 20).to_s\n elsif old_id == \"89\"\n return \"70\"\n elsif old_id == \"90\"\n return \"69\"\n elsif old_id.to_i <= 93\n return (old_id.to_i - 20).to_s\n else \n return (old_id.to_i - 21).to_s\n end\n end",
"def attrib_before_save(attrib)\n attrib = attrib.to_s\n\n # if id just changed from nil then we know the last save was actually a create\n # in this case we just return the current value\n # if the value didn't change, we also just return the current value\n if previous_changes['id'] && previous_changes['id'].first.nil? || !previous_changes.has_key?(attrib)\n send(attrib)\n\n # otherwise, we return the old value\n else\n previous_changes[attrib].first\n end\n end",
"def should_generate_new_friendly_id?\n name_changed? || super\n end",
"def id_changed?\n to_id != @attributes[self.class.id_method]\n end",
"def old_attributes\n @old_attributes ||= begin\n query = @relation.select(:id, *@updates.keys).to_sql\n result = ActiveRecord::Base.connection.exec_query(query)\n result.to_hash\n end\n end",
"def temp_id\n #reverting to just plain id, see issue #89\n self.id\n end",
"def unfriendly_id?; end",
"def changed\n mutations_from_database.changed_attribute_names\n end",
"def changed\n self.class.fields.select do |field|\n field[0] != '_' and self._old_values[field] != self.send(field)\n end\n end",
"def getOld oldAttr\n\t\treturn @old[\"#{oldAttr}\"]\n\tend",
"def should_generate_new_friendly_id?\n datetime_from_exif_changed? ||\n datetime_from_file_changed? ||\n datetime_from_manual_entry_year_changed? ||\n datetime_from_manual_entry_month_changed? ||\n datetime_from_manual_entry_day_changed? ||\n datetime_from_manual_entry_hour_changed? ||\n datetime_from_manual_entry_minute_changed? ||\n datetime_from_manual_entry_second_changed? ||\n source_attachment.changed? ||\n source_catalog_file_path_changed? ||\n source_type_changed? ||\n super\n end",
"def real_id\n @id\n end",
"def real_id\n @id\n end",
"def should_generate_new_friendly_id?\n company_name_changed? || title_changed? || status_changed? || super\n end",
"def old_couple\n @old_couple = @students_id - @pair\n @students_id.delete(@pair)\n end",
"def friendly_id\n slug(true).to_friendly_id\n end",
"def attribute_changes\n attributes.changes\n end",
"def duplicant_changed? \n\t\t\treturn false if !self.link_fieldlet.old_entity\n\t\t\tself.link_fieldlet.entity[:id] != self.link_fieldlet.old_entity[:id]\n\t\tend",
"def old_value; end",
"def old_count\n model.find(id)[field]\n end",
"def changed_fields\n items = @resource.changed_from_previous_curated\n return ['none'] unless items.present?\n\n items\n end",
"def attributes_in_database\n mutations_from_database.changed_values\n end",
"def resource_id_column\n\t\t\t\t\t\traise \"Not implemented.\"\n\t\t\t\t\tend",
"def changed_columns\n cc = super\n changed = []\n v = @values\n if vh = @values_hashes\n (vh.keys - cc).each{|c| changed << c unless v.has_key?(c) && vh[c] == v[c].hash}\n end\n cc + changed\n end",
"def changed_attributes\n return {} if @_hr_changed.nil?\n @_hr_changed.select{|k,v| v}.keys.inject({}) {|h,k| h[k]=self[k]; h}\n end",
"def record_changelog_identifier\n\t\tself.valve_code\n\tend",
"def changed_attribute_names_to_save\n mutations_from_database.changed_attribute_names\n end",
"def normalize_friendly_id(input)\n input\n end",
"def old_attributes\n (audited_changes || {}).inject({}.with_indifferent_access) do |attrs, (attr, values)|\n attrs[attr] = Array(values).first\n attrs\n end\n end",
"def changed_by\n return @changed_by\n end",
"def updatable_attributes\n [:name]\n end",
"def legacy_id=(value)\n @legacy_id = value\n end",
"def changed_columns\n cc = super\n cc = cc.dup if frozen?\n deserialized_values.each{|c, v| cc << c if !cc.include?(c) && original_deserialized_value(c) != v} \n cc\n end",
"def to_param\n (friendly_id || id).to_s\n end",
"def to_param\n (friendly_id || id).to_s\n end",
"def to_param\n (friendly_id || id).to_s\n end",
"def to_param\n (friendly_id || id).to_s\n end",
"def fire_duplicate_id(old_entity, new_entity); end",
"def attribute_change(attr)\n [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)\n end",
"def reserved_tracked_fields\n @reserved_tracked_fields ||= begin\n fields = ['_id', history_trackable_options[:version_field].to_s]\n modifier_field = history_trackable_options[:modifier_field]\n fields << \"#{modifier_field}_id\" if modifier_field\n fields\n end\n end",
"def field_changes\n table_name = if table_name_changed\n prev_table_name\n else\n self.table_name\n end\n\n begin\n cols = table_columns\n old_colnames = cols.map(&:name) - standard_columns\n old_colnames = old_colnames.reject { |f| f.index(/^embedded_report_|^placeholder_/) }\n rescue StandardError\n return\n end\n\n fields = migration_fields_array\n new_colnames = fields.map(&:to_s) - standard_columns\n\n added = new_colnames - old_colnames\n removed = old_colnames - new_colnames\n changed = {}\n db_configs.each do |k, v|\n current_type = cols.find { |c| c.name == k.to_s }&.type\n next unless v[:type] && current_type\n\n expected_type = v[:type]&.to_sym\n current_type = :timestamp if current_type == :datetime\n changed[k.to_s] = expected_type if current_type != expected_type\n end\n\n if belongs_to_model\n belongs_to_model_id = \"#{belongs_to_model}_id\"\n removed -= [belongs_to_model_id]\n end\n\n [added, removed, changed, old_colnames]\n end",
"def local_changes(attributes_to_save, attributes_before_edit)\n (attributes_to_save.diff attributes_before_edit).keys\n end",
"def normalize_friendly_id(string)\n name\n end",
"def change\n attributes.fetch(:change)\n end",
"def normalize_friendly_id(string); string.upcase.gsub(\"-\", \".\") end",
"def should_generate_new_friendly_id?\n attribute_changed?(title)\n end",
"def update_timestamp\n self.fields_last_modified = {\n columns_changeable: columns_changeable,\n columns_visible: columns_visible,\n filters: filters\n }.hash.to_s(36)[1..5]\n end",
"def attribute_previous_change(attr_name)\n mutations_before_last_save.change_to_attribute(attr_name.to_s)\n end",
"def to_id(use_old = false)\n use_old ? @attributes[self.class.id_method] : send(self.class.id_method)\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 dirty_attributes\n changed.inject({}) { |h, k| h[k] = attributes[k.to_s]; h }\n end",
"def attribute_previously_was(attr_name) # :nodoc:\n mutations_before_last_save.original_value(attr_name.to_s)\n end",
"def save_old_profile\n @_old_profile_id = profile_id_change ? profile_id_change.first : false\n true\n end",
"def id; \"#{@x}-#{@y}\"; end",
"def update \n if @locationtour.update(locationtour_params)\n p '-------------modual_ids-------------'\n p @modual_ids = params[:h].split(',').map(&:to_i)\n p '-------------locationtour.hotel_ids-------------'\n @locationtour.hotel_ids = @modual_ids\n @locationtour.save \n redirect_to :back\n end\n end",
"def changed_tags\n @changed_values.keys.map { |key| MiniExiftool.original_tag(key) }\n end",
"def timestamp_attributes_for_update\n ['last_activity']\n end",
"def to_s\n format '%s: %s => %s', name, old_value, new_value\n end",
"def update_timestamp\n self.fields_last_modified = {\n columns_changeable: self.columns_changeable,\n columns_visible: self.columns_visible,\n filters: self.filters}.hash.to_s(36)[1..5]\n end",
"def friendly_id_config\n self.class.friendly_id_config\n end",
"def change_set_id\n data[:change_set_id]\n end",
"def machine_id_changed\n\t\t\tend",
"def changed_columns\n @changed_columns ||= []\n end",
"def changed_columns\n @changed_columns ||= []\n end",
"def attribute_id\n @attributes.each { | id, value | return id }\n end",
"def id_for_update\n { self.class.primary_key.to_s => __id }\n end",
"def pending_modified_values\n @dbi.pending_modified_values\n end",
"def pending_modified_values\n @dbi.pending_modified_values\n end",
"def change_key\n return @change_key\n end",
"def should_generate_new_friendly_id?\n\t name_changed?||self.slug.nil?\n\tend",
"def current_alter\n @current_alter\n end",
"def current_alter\n @current_alter\n end",
"def current_alter\n @current_alter\n end",
"def current_alter\n @current_alter\n end",
"def current_alter\n @current_alter\n end",
"def original_primary_key\n if sourceRD.naturalKey == \"id\"\n \"original_id\"\n else\n sourceRD.naturalKey\n end\n end",
"def prepare_changes(columns)\n self.changes.symbolize_keys.slice(*columns).map do |column, vals|\n [column, vals.last.to_i - vals.first.to_i]\n end.to_h\n end"
] |
[
"0.574171",
"0.5280585",
"0.5280585",
"0.5245634",
"0.5233118",
"0.5188976",
"0.51878655",
"0.51878655",
"0.51878655",
"0.51878655",
"0.51878655",
"0.5180392",
"0.5126743",
"0.51084876",
"0.51058644",
"0.50968534",
"0.5092864",
"0.50747055",
"0.50657624",
"0.50622606",
"0.5051626",
"0.50510955",
"0.50011677",
"0.49856088",
"0.4966424",
"0.4953472",
"0.49460888",
"0.49450165",
"0.493676",
"0.49224418",
"0.49182996",
"0.49142438",
"0.49059993",
"0.48965126",
"0.48965126",
"0.4881978",
"0.48762336",
"0.4875467",
"0.48710284",
"0.4870908",
"0.48681268",
"0.4867357",
"0.48629233",
"0.48597968",
"0.48497167",
"0.48295277",
"0.4820971",
"0.4820874",
"0.48158476",
"0.48094842",
"0.4804826",
"0.47788084",
"0.4772068",
"0.47716308",
"0.4748528",
"0.4731612",
"0.4731612",
"0.4731612",
"0.4731612",
"0.47202352",
"0.47001305",
"0.46994767",
"0.4696109",
"0.46958455",
"0.46898848",
"0.46866786",
"0.468431",
"0.4674789",
"0.467208",
"0.46711376",
"0.46689865",
"0.4666108",
"0.46656358",
"0.46599957",
"0.46589905",
"0.4657018",
"0.46568543",
"0.46541816",
"0.46481535",
"0.4647223",
"0.4645519",
"0.46404153",
"0.46387616",
"0.4638451",
"0.4635255",
"0.4635255",
"0.46329495",
"0.4630322",
"0.4627212",
"0.4627212",
"0.46211693",
"0.46146244",
"0.4611637",
"0.4611637",
"0.4611637",
"0.4611637",
"0.4611637",
"0.46071592",
"0.460364"
] |
0.7785411
|
1
|
Update the slugs for any model that is using this model as its FriendlyId scope.
|
def update_scopes
if changes = friendly_id_changes
friendly_id_config.child_scopes.each do |klass|
Slug.update_all "scope = '#{changes[1]}'", ["sluggable_type = ? AND scope = ?", klass.to_s, changes[0]]
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update_scopes\n if @old_friendly_id != friendly_id\n friendly_id_config.child_scopes.each do |klass|\n Slug.all(:sluggable_type => klass, :scope => @old_friendly_id).update(:scope => friendly_id)\n end\n end\n end",
"def update_dependent_scopes\n if slugs(true).size > 1 && @new_friendly_id\n friendly_id_config.child_scopes.each do |klass|\n Slug.update_all \"scope = '#{@new_friendly_id}'\", [\"sluggable_type = ? AND scope = ?\",\n klass.to_s, slugs.second.to_friendly_id]\n end\n end\n end",
"def update_dependent_scopes\n return unless friendly_id_config.class.scopes_used?\n # slugs.reload.size == 1, slugs.dirty? == true\n if slugs.size > 1 && @new_friendly_id\n friendly_id_config.child_scopes.each do |klass|\n # slugs.first -- ordering not respected when dirty\n Slug.all(:sluggable_type => klass, :scope => slugs.first.to_friendly_id).update(:scope => @new_friendly_id)\n end\n end\n end",
"def update_dependent_scopes\n return unless friendly_id_config.class.scopes_used?\n if slugs(true).size > 1 && @new_friendly_id\n friendly_id_config.child_scopes.each do |klass|\n Slug.update_all \"scope = '#{@new_friendly_id}'\", [\"sluggable_type = ? AND scope = ?\",\n klass.to_s, slugs.second.to_friendly_id]\n end\n end\n end",
"def make_slugs_unique\n slugs.each do |column, (_, scope_column)|\n next unless changes.key?(column.to_s)\n\n current_slug = send(column)\n scope_value = scope_column ? send(scope_column) : nil\n while self.class.slug_taken?(column, current_slug, scope_column, scope_value)\n current_slug = Slug.increment(current_slug)\n send(\"#{column}=\", current_slug)\n end\n end\n end",
"def generate_slugs\n\t\tif !RicWebsite.slug_model.nil? && !self.name.blank?\n\t\t\t\n\t\t\t# Get all models relevant for slug\n\t\t\tslug_models = []\n\t\t\tslug_models << self\n\n\t\t\t# Compose URL\n\t\t\turl = URL.gsub(/:id/, self.id.to_s)\n\t\t\ttmp_uri = URI.parse(url)\n\t\t\t\n\t\t\tI18n.available_locales.each do |locale|\n\t\t\t\ttranslation = RicWebsite.slug_model.compose_translation(locale, models: slug_models, label: :name)\n\t\t\t\tRicWebsite.slug_model.add_slug(locale, tmp_uri.path, translation)\n\t\t\tend\n\t\tend\n\tend",
"def update_slug\n source = self[model.slug_options[:gen_from]] || \"\"\n slug = ActiveSupport::Inflector.transliterate(source) # remove accents\n .gsub(/&/,'and') # switch out &\n .gsub(/@/,'at') # switch out @\n .parameterize('-') # cleanup remaining odd characters and link with hyphens\n if slug.length > 0\n if s = unique_slug(slug)\n slug = s\n end\n else\n slug = random_slug\n end\n self.slug = slug\n end",
"def set_slug\n if self.class.friendly_id_options[:use_slug] && new_slug_needed?\n @most_recent_slug = nil\n slug_attributes = {:name => slug_text}\n if friendly_id_options[:scope]\n scope = send(friendly_id_options[:scope])\n slug_attributes[:scope] = scope.respond_to?(:to_param) ? scope.to_param : scope.to_s\n end\n # If we're renaming back to a previously used friendly_id, delete the\n # slug so that we can recycle the name without having to use a sequence.\n slugs.find(:all, :conditions => {:name => slug_text, :scope => scope}).each { |s| s.destroy }\n slug = slugs.build slug_attributes\n slug\n end\n end",
"def normalize_slug\n self.slug = normalize_friendly_id(slug)\n end",
"def normalize_slug\n self.slug = normalize_friendly_id(slug)\n end",
"def normalize_slug\n self.slug = normalize_friendly_id(slug)\n end",
"def set_slug(normalized_slug = nil)\n if should_generate_new_friendly_id?\n candidates = FriendlyId::Candidates.new(self, normalized_slug || send(friendly_id_config.base))\n slug = slug_generator.generate(candidates) || resolve_friendly_id_conflict(candidates)\n send \"#{friendly_id_config.slug_column}=\", slug\n end\n end",
"def reset_slug!\n reset__slugs!\n end",
"def set_slug_cache\n if new_cache_needed?\n begin\n send \"#{friendly_id_config.cache_column}=\", slug.to_friendly_id\n update_without_callbacks\n rescue ActiveRecord::StaleObjectError\n reload\n retry\n end\n end\n end",
"def set_slug_cache\n if new_cache_needed?\n send \"#{friendly_id_config.cache_column}=\", slug.to_friendly_id\n send :update_without_callbacks\n end\n end",
"def reset_all_slugs!(collection = [])\n collection = collection.presence || self.all\n\n collection.each do |record|\n record.wipe_slugs\n\n # update wiped slugs without triggering sluggable\n slug_data = {}\n slug_fields = self.all_slug_fields\n slug_fields.each do |options|\n key = options[:key]\n slug_data[key] = record.send(:\"#{key}\")\n end\n\n record.set(slug_data)\n end\n\n # now update all with triggering sluggable\n collection.each do |record|\n record.set_slug\n record.save(validate: false)\n end\n end",
"def update_slug\n get_resource.slug = nil\n get_resource.save!\n end",
"def set_slug!\n build_slug\n method(:set).arity == 1 ? set(_slugs: _slugs) : set(:_slugs, _slugs)\n end",
"def normalize_friendly_id_with_marketable_urls(slug_string)\n FriendlyIdPath.normalize_friendly_id_with_marketable_urls(slug_string)\n end",
"def destroy_slugs\n\t\tif !RicWebsite.slug_model.nil?\n\t\t\turl = URL.gsub(/:id/, self.id.to_s)\n\t\t\ttmp_uri = URI.parse(url)\n\t\t\tI18n.available_locales.each do |locale|\n\t\t\t\tRicWebsite.slug_model.remove_slug(locale, tmp_uri.path)\n\t\t\tend\n\t\tend\n\tend",
"def set_slug_cache\n if new_cache_needed?\n self.attribute_set(friendly_id_config.cache_column, slug.to_friendly_id)\n self.save_self(false) # save!\n end\n end",
"def update_descendants_slugs\n if has_children?\n descendants.each do |child|\n child.slug = [child.parent.slug, child.slug.split('/').last].join('/')\n child.save!\n end\n end\n end",
"def normalize_friendly_id(slug_string)\n FriendlyIdPath.normalize_friendly_id(slug_string)\n end",
"def generate_slug!\n\t\tself.slug = self.id.to_s(36)\n\t\tsave\n\tend",
"def set_slug\n self.slug = self.title.parameterize\n end",
"def set_slug\n self.slug = make_slug(name)\n end",
"def scope_for_slug_generator; end",
"def reset_slug\n set_slug(:force => true)\n end",
"def set_slug\n self.slug = full_name.parameterize\n end",
"def build_slug\n return unless new_slug_needed?\n self.slug = slugs.build :name => slug_text.to_s, :scope => friendly_id_config.scope_for(self)\n end",
"def set_slug\n write_attribute(:cached_slug, self.to_slug)\n end",
"def generate_slugs(options = {})\n\t\t\t\t\t\n\t\t\t\t\t# Generate slug in this model\n\t\t\t\t\tif !RicWebsite.slug_model.nil? && self.url_was != self.url && !self.url_was.blank?\n\t\t\t\t\t\tI18n.available_locales.each do |locale|\n\t\t\t\t\t\t\tRicWebsite.slug_model.remove_slug(locale, self.url_was)\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\t\tif !RicWebsite.slug_model.nil? && !self.url.blank?\n\t\t\t\t\t\ttmp_uri = URI.parse(self.url)\n\t\t\t\t\t\tI18n.available_locales.each do |locale|\n\t\t\t\t\t\t\ttranslation = RicWebsite.slug_model.compose_translation(locale, models: self.self_and_ancestors, label: :title)\n\t\t\t\t\t\t\tRicWebsite.slug_model.add_slug(locale, tmp_uri.path, translation)\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\n\t\t\t\t\t# Propagate to other models\n\t\t\t\t\tif options[:disable_propagation] != true\n\t\t\t\t\t\t\n\t\t\t\t\t\t# Propagate to parent\n\t\t\t\t\t\tself.parent.generate_slugs(disable_propagation: true) if self.parent\n\n\t\t\t\t\t\t# Propagate to descendants\n\t\t\t\t\t\tself.descendants.each do |descendant|\n\t\t\t\t\t\t\tdescendant.generate_slugs(disable_propagation: true)\n\t\t\t\t\t\tend\n\n\t\t\t\t\tend\n\n\t\t\t\tend",
"def friendly_id_config; end",
"def destroy_slugs_before(options = {})\n\n\t\t\t\t\t# Destroy slug of this model\n\t\t\t\t\tif !RicWebsite.slug_model.nil? && !self.url.blank?\n\t\t\t\t\t\ttmp_uri = URI.parse(self.url)\n\t\t\t\t\t\tI18n.available_locales.each do |locale|\n\t\t\t\t\t\t\tRicWebsite.slug_model.remove_slug(locale, tmp_uri.path)\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\n\t\t\t\t\t# Propagate to other models\n\t\t\t\t\tif options[:disable_propagation] != true\n\t\t\t\t\t\t\n\t\t\t\t\t\t# Propagate to descendants\n\t\t\t\t\t\tself.descendants.each do |descendant|\n\t\t\t\t\t\t\tdescendant.destroy_slugs_before(disable_propagation: true)\n\t\t\t\t\t\tend\n\n\t\t\t\t\tend\n\n\t\t\t\tend",
"def manage_slug\n \tself.slug = self.title.parameterize if self.slug.blank?\n end",
"def update_urlname!\n names = ancestors.visible.contentpages.where(language_root: nil).map(&:slug).compact\n new_urlname = (names << slug).join('/')\n if urlname != new_urlname\n legacy_urls.create(urlname: urlname)\n update_column(:urlname, new_urlname)\n end\n end",
"def normalize_friendly_id(slug_str)\n super.gsub(\"-\", \"\")\n end",
"def slug_update\n slug = params[:slugfilter].upcase\n slug = \"\" if params[:clear]\n session[:slugfilter] = slug\n # TODO restore page state (e.g. drilldown)\n render :js => \"window.location.reload()\"\n end",
"def friendly_id\n slug(true).to_friendly_id\n end",
"def model_slug\n slug\n end",
"def slugify\n self.slug = name.parameterize\n end",
"def set_slug\n self.slug = KeyGenerator.generate(8) if self.slug.blank?\n end",
"def set_slug\n if self.slug.blank?\n self.slug = self.name.parameterize.downcase unless self.name.nil?\n end\n end",
"def clear_slug!\n self._slugs = []\n end",
"def normalize_friendly_id(string)\n if slug.blank?\n super\n else\n super(slug)\n end\n end",
"def slugify\n self.slug = name.parameterize \n end",
"def normalize_friendly_id(input)\n input.to_s.to_slug.normalize.to_s\n end",
"def normalize_friendly_id(input)\n input.to_s.to_slug.normalize.to_s\n end",
"def normalize_friendly_id(input)\n input.to_s.to_slug.normalize.to_s\n end",
"def generate_slug\n self.slug = self.name.parameterize\n end",
"def normalize_friendly_id(string); string.upcase.gsub(\"-\", \".\") end",
"def set_slug\n self.slug = title.parameterize\n end",
"def friendly_id; end",
"def normalize_friendly_id(text)\n text.to_s.to_slug.normalize.to_s\n end",
"def set_slug(normalized_slug = T.unsafe(nil)); end",
"def slug=(s)\n if (new_slug = fit_slug_to_length(s, 64)) != slug\n super(new_slug)\n update_path\n end\n end",
"def set_slug\n self._slug = self._label.dup if self._slug.blank? && self._label.present?\n\n if self._slug.present?\n # we can't rely on the self.site property yet (brand new entry for instance)\n if self.content_type.site.allow_dots_in_slugs?\n self._slug.pathify!\n else\n self._slug.permalink!\n end\n\n self.find_next_unique_slug if self.slug_already_taken?\n end\n\n # all the site locales share the same slug ONLY IF the entry is not localized.\n self.set_same_slug_for_all_site_locales if !self.localized?\n end",
"def normalize_friendly_id(string)\n super.gsub(\"-\", \".\")\n end",
"def set_same_slug_for_all_site_locales\n return unless self.set_site.localized?\n\n default_slug = self._slug\n\n self.set_site.locales.each do |locale|\n ::Mongoid::Fields::I18n.with_locale(locale) do\n self._slug = default_slug\n end\n end\n end",
"def set_slug\n \t \tself.slug = name.to_slug unless name.blank?\n\tend",
"def slug\n ActiveModel::Naming.route_key(self.class.model)\n end",
"def normalize_friendly_id(string)\n name\n end",
"def normalize_friendly_id(input)\n input\n end",
"def slug\n @attributes[:slug] = @attributes[:name] && PublicEarth::Db::Collection.create_slug(@attributes[:name]) unless @attributes[:slug] \n @attributes[:slug]\n end",
"def build_slug\n return unless new_slug_needed?\n @slug = slugs.new(:name => slug_text, :scope => friendly_id_config.scope_for(self))\n raise FriendlyId::BlankError unless @slug.valid?\n @new_friendly_id = @slug.to_friendly_id\n @slug\n end",
"def normalize_friendly_id(string)\n super[0..59]\n end",
"def before_update\n mark_site_modified if changed_columns.include?(:slug)\n super\n end",
"def slug_candidates\n [\n :name_to_url,\n [:name_to_url, :sku],\n [:name_to_url, :sku, :site_id]\n ]\n end",
"def slug_candidates\n [\n :name_to_url,\n [:name_to_url, :sku],\n [:name_to_url, :sku, :site_id]\n ]\n end",
"def parameterize_slug\n self.slug = self.title if self.slug.empty?\n self.slug = self.slug.downcase.parameterize\n end",
"def set_slug\n self.slug = title.downcase.gsub(\" \", \"_\") if slug.blank?\n slug\n end",
"def before_save\n if !new? && (title = fields[title_field_name])\n set_slug_from_title(title)\n end\n fix_generated_slug_conflicts if changed_columns.include?(:slug)\n super\n end",
"def set_admin_social_network\n @social_network = SocialNetwork.find_by_slug(params[:id])\n end",
"def normalize_friendly_id(text)\n text.to_s.to_slug.normalize.to_s\n end",
"def set_site\n @site = Site.find_by slug: params[:slug]\n end",
"def friendly\n # Guess what? This causes Rails to invoke `extend` on the scope, which has\n # the well-known effect of blowing away Ruby's method cache. It would be\n # possible to make this more performant by subclassing the model's\n # relation class, extending that, and returning an instance of it in this\n # method. FriendlyId 4.0 did something similar. However in 5.0 I've\n # decided to only use Rails's public API in order to improve compatibility\n # and maintainability. If you'd like to improve the performance, your\n # efforts would be best directed at improving it at the root cause\n # of the problem - in Rails - because it would benefit more people.\n all.extending(friendly_id_config.finder_methods)\n end",
"def normalize_friendly_id(slug_string)\n return super if self.language_code ? self.language_code == \"en\" : I18n.locale_language == :en\n options = friendly_id_config.babosa_options\n language = Utility.english_language_name(self.language_code || I18n.locale_language) || :english\n slug_string.normalize! options.merge(:transliterations => \"#{language}\".underscore.to_sym)\n end",
"def normalize_friendly_id(name)\n name_as_slug = name.to_s.to_slug.normalize(transliterations: :russian).to_s\n add_parent_slug(name_as_slug)\n end",
"def set_slug\n self.slug = title.downcase.tr(\" \", \"_\") if slug.blank?\n slug\n end",
"def set_slug\n self.translated_in.each do |locale|\n Locomotive::Mounter.with_locale(locale) do\n # first attempt from the label\n if self._slug.blank?\n self._slug = self._label.try(:dup)\n end\n\n # from the content type itself\n if self._slug.blank?\n self._slug = self.content_type.send(:label_to_slug)\n end\n\n self._slug.permalink!\n\n self._slug = self.next_unique_slug if self.slug_already_taken?\n end\n end\n\n self.fill_with_default_slug\n end",
"def normalize_friendly_id(input)\n input.to_s.to_url\n end",
"def normalize_friendly_id(input)\n input.to_s.to_url\n end",
"def normalize_friendly_id(input)\n input.to_s.to_url\n end",
"def normalize_friendly_id(input)\n input.to_s.to_url\n end",
"def set_site\n @site = Site.find_by(slug: params[:site_slug])\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def set_Slug(value)\n set_input(\"Slug\", value)\n end",
"def normalize_friendly_id(string)\n\t super[0..20]\n\tend"
] |
[
"0.7132532",
"0.6879803",
"0.6831018",
"0.67264354",
"0.6510821",
"0.6416128",
"0.6412397",
"0.63590467",
"0.62244314",
"0.61868393",
"0.61790764",
"0.6104081",
"0.6065063",
"0.60566974",
"0.6016339",
"0.60075444",
"0.60000193",
"0.59657824",
"0.59601057",
"0.5959993",
"0.586155",
"0.5819869",
"0.5749928",
"0.56330854",
"0.5583963",
"0.5569673",
"0.55537945",
"0.55484456",
"0.55416775",
"0.5515914",
"0.54865974",
"0.54636425",
"0.54423887",
"0.5422159",
"0.5390379",
"0.5371923",
"0.5370389",
"0.5366942",
"0.5350561",
"0.5350287",
"0.5347492",
"0.53437287",
"0.53421485",
"0.53390783",
"0.53355294",
"0.5325652",
"0.53179973",
"0.53179973",
"0.53179973",
"0.5300734",
"0.53005606",
"0.5257386",
"0.52489257",
"0.52409846",
"0.5238013",
"0.52353454",
"0.5228952",
"0.52266556",
"0.5220698",
"0.51930475",
"0.518923",
"0.515434",
"0.514289",
"0.51374185",
"0.5120801",
"0.5120568",
"0.5113674",
"0.51101166",
"0.51101166",
"0.51065946",
"0.51054347",
"0.5096528",
"0.50949955",
"0.5087738",
"0.5083423",
"0.50823164",
"0.50713897",
"0.5069604",
"0.50678337",
"0.5051569",
"0.50422007",
"0.50422007",
"0.50422007",
"0.50422007",
"0.5034546",
"0.50321996",
"0.50321996",
"0.50321996",
"0.50321996",
"0.5031848",
"0.5031848",
"0.5031848",
"0.5031848",
"0.5031588",
"0.5031588",
"0.5031588",
"0.5031588",
"0.5031588",
"0.50309837"
] |
0.66404086
|
5
|
set the choosen number into the board
|
def set(num)
player_id = @players[@turn % 2].id
@board[num - 1] = @player_char[player_id]
@turn += 1
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_player(input, player_num)\n board[input.to_i] = player_num\n end",
"def set_board(board)\n @board = board\n end",
"def set\n\t$one = \"1\"\n\t$two = \"2\"\n\t$three = \"3\"\n\t$four = \"4\"\n\t$five = \"5\"\n\t$six = \"6\"\n\t$seven = \"7\"\n\t$eight = \"8\"\n\t$nine = \"9\"\n\t$turn = 0\t\t\nend",
"def player_picks_square(b)\n puts \"Pick a square (1 - 9):\"\n position = gets.chomp.to_i\n b[position] = 'X'\nend",
"def move(board,position,choice=\"X\")\n iPosition = position.to_i\n board[iPosition-1] = choice\nend",
"def player_picks_square(b)\n puts \"Pick a square: (1 - 9):\"\n position = gets.chomp.to_i\n b[position] = 'X'\nend",
"def set( x, y, number=nil )\n correct = (0..@size_pow-1).to_a\n if ( correct.include? x ) && ( correct.include? y) then\n @board[x][y] = number\n return true\n else\n puts \"Set error, wrong coordinates!\"\n false\n end\n end",
"def set(x,y)\n @board[x][y] = 1\n return self\n end",
"def set_board\n @board = Board.find(params[:id]||params[:board_id])\n end",
"def choose_b_position\n puts \"What number on the board do you choose?\"\n @choice = gets.chomp.to_i\n # if human #set up X or O for player here?\n # spaces.index(human.choice) = \"X\"\n # else\n # spaces.index(computer.choice etc etc) = \"O\"\n # end\n end",
"def set_piece(player,location) #takes the arguments player and location\n\t\t@piece=player.piece #defines piece as the player's number (either 1 or 2)\n\t\trow=(location-1)/4 #takes the value of location (1-16) and converts it into a row coordinate 0, 1, 2, or 3\n\t\tcolumn=(location+3)%4 #takes the value of location (1-16) and converts it into a column coordinate 0, 1, 2, or 3\n\t\t@board[row][column]=@piece #defines the cell that the player has just selected as the player's number (1 or 2)\n\t\t@size+=1 #we count each move after its been made which is used in the function below, check_full?\n\tend",
"def set_board\n @board = Board.find(params[:board_id])\n end",
"def set_board\n @board = Board.find(params[:board_id])\n end",
"def enter_value(row,col,value)\n col = @hash[col] if col.is_a? String#interpret 'a' to mean 1\n @board[row][col].chess_piece = value\n end",
"def move(board, num, mark=\"X\")\n num = num.to_i\n board[num-1]=mark\nend",
"def []=(pos, value)\n @board[pos[0]][pos[1]] = value\n end",
"def move(board, index, player_choice = \"X\")\n board[index] = player_choice\nend",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def player_choice(b)\n begin\n puts \"\\n\\nChoose an empty position (from 1 to 9) to place a piece:\\n\\n\"\n playerchoice = gets.chomp.to_i\n end until board_available(b).include?(playerchoice)\n b[playerchoice] = \"X\"\nend",
"def set_board\n @board = current_user.boards.find(@list[:board_id])\n end",
"def set_case(case_selected, piece)\n grid[case_selected[0]][case_selected[1]] = piece\n unless piece.nil?\n piece.location = case_selected\n end\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def turn\n puts \"#{@current_player.name}\\'s turn. Choose your cell (1-9)\" \n choice = gets.chomp.to_i\n if choice > 9 || choice < 1\n puts \"Warning : number must be between 1 and 9\"\n elsif @current_player.move(choice) != false\n @winner = @current_player if @current_player.winner?\n @turn += 1\n switch_player\n end\n end",
"def []=(position, value)\n row, col = position\n @board[row][col] = value\n end",
"def set_move(player, square_number)\n board_iterate do |element, row, col|\n @board[row][col] = player.piece if element == square_number\n end\n end",
"def set_disc(row, col, value)\n @board[row * @size + col] = value\n end",
"def move(index, value=\"X\")\n @board[index] = value\nend",
"def update (player_id_choice, value_X_O)\n\n\t\t@boardcase_array.each {|element| \n\t\t\tif element.boardcase_id == player_id_choice\n\t\t\t\telement.boardcase_value = value_X_O\n\t\t\t\tbreak\n\t\t\tend\n\t\t}\n\n\tend",
"def set_board\n @board =current_user.boards.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:board_id])\n end",
"def update_position\r\n # update selection for grid[col][row]\r\n #puts \"#{@grid[2][0]}\"\r\n \r\n puts \"Enter the row, column and value for your selection.\"\r\n print \"row: \"\r\n row = gets.chomp.to_i\r\n print \"column: \"\r\n col = gets.chomp.to_i\r\n print \"value: \"\r\n val = gets.chomp.to_s\r\n puts\r\n\r\n @grid[row][col] = val\r\n\r\n end",
"def o_board_change (num)\n def space_check (space,board_state)\n if board_state.include?(space)\n return true\n else\n puts \"You've entered an invalid space option.\"\n $i -= 1\n return false\n end\n end\n \n puts \" #{num[0]} | #{num[1]} | #{num[2]}\\n-----------\\n #{num[3]} | #{num[4]} | #{num[5]}\\n-----------\\n #{num[6]} | #{num[7]} | #{num[8]}\"\n \n puts \"Player one, please choose a location for your O.\"\n \n o = gets.chomp\n o_int = o.to_i\n \n if space_check(o_int,num) == true\n space_index = num.index(o_int)\n num[space_index] = \"O\"\n $j = 0\n end\n return num\n end",
"def set_square(y,x,value)\n\t\t@board[y][x] = value\n\tend",
"def player_one(board, choice)\n\n if choice == 1 \n board[0] = \"X \"\n elsif choice == 2\n board[1] = \" X \"\n elsif choice == 3 \n board[2] = \" X \" \n elsif choice == 4 \n board[3] = \" X \"\n elsif choice == 5\n board[4] = \" X \"\n elsif choice == 6\n board[5] = \" X \"\n elsif choice == 7\n board[6] = \" X \"\n elsif choice == 8 \n board[7] = \" X \"\n elsif choice == 9\n board[8] = \" X \" \n end\nend",
"def set_board\n @board = Board.find_by_link(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def set_board\n @board = Board.find(params[:id])\n end",
"def update_board(mark, position)\n position = position.to_i\n\n @play_area[position] = mark\n end",
"def set_at(coords, piece)\n @board[coords[0]][coords[1]] = piece\n end",
"def place_piece(selected_col)\n\t\t# this is to set it so if that if the\n\t\t# user selects, say, column 1, the selected\n\t\t# col will be index 0\n\t\tselected_col -= 1\n\t\tbottom_row = 6\n\t\tbottom_row.downto(0) do |row|\n\t\t\tif @board[row][selected_col] == 0\n\t\t\t\t@board[row][selected_col] = @player_turn\n\t\t\t\tbreak\n\t\t\tend\n\t\tend\n\tend",
"def set_move move\n@board[move] = @player\nend",
"def turn\n puts \"Pick a spot by number starting from 1 in top left corner\"\n position = gets.chomp!.to_i\n @position = Integer(position) > 0 && Integer(position) < 10 ? position - 1 : not_valid\n end",
"def set_board\n # Create first ship\n set_ship(Ship.new(3))\n\n # Create second ship\n set_ship(Ship.new(4))\n end",
"def set_coordinate_piece(coordinate, piece)\n @board[coordinate] = piece\n end",
"def move(index, value = \"X\")\n @board[index] = value\n end",
"def []=(pos, value)\n if valid_pos?(pos)\n row, col = pos\n if @grid[row][col].given == true\n @grid[row][col].value = value\n else\n \"Cannot change tiles that have already been set by the puzzle\"\n end\n else\n puts \"Invalid position\"\n end\n end",
"def select_board(board_id)\n self.current_board_id = board_id\n save! if changed?\n end",
"def set_numbers\n @board.each.with_index do |arr, x|\n arr.each.with_index do |e, y|\n next if e.value == \"O\"\n traps = count_traps(x, y)\n next if traps == 0\n e.value = traps\n end\n end\n end",
"def set(n)\r\n self.value=n\r\n end",
"def move(index, value)\n @board[index] = value\n end",
"def move(index, value)\n @board[index] = value\n end",
"def set_livings_cell\n @board[2][2] = 1\n @board[2][3] = 1\n @board[3][3] = 1\n @board[3][4] = 1\n @board[4][4] = 1\n end",
"def update_board(spot, symbol)\n @board[spot[0]][spot[1]] = symbol\n end",
"def set_board\r\n #ページに表示するデータを取得する。\r\n @board = Board.find(params[:id])\r\n end",
"def choose_move\n puts \"#{current_player}, select a cell to place your #{whose_turn}. Select a number between 1 - 9.\"\n move = gets.chomp.to_i\n puts\n\n # If move is valid and is not taken, then create a key-value pair in @taken: number => X or O.\n if valid_move?(move) && !taken?(move)\n @taken[move] = whose_turn\n update_board(move)\n # When it is not a valid move and the cell is not taken\n elsif !valid_move?(move) && !taken?(move)\n puts \"That is not a valid choice. Please select a number between 1 and 9.\"\n \t# When it is a valid move and the cell is taken \n elsif valid_move?(move) && taken?(move)\n puts \"That one has already been taken. Please select another cell.\"\n end\n end",
"def set_number\n binding.pry\n @number = Number.find(params[:id])\n end",
"def set_num\n @num = Num.find(params[:id])\n end",
"def move(board, index, value = 'X')\n board[index] = value\nend",
"def set_cell(cell, state)\n @board[cell] = state\n end",
"def move(board, index, value = \"X\")\n board[index] = value\nend",
"def move(input, value = \"X\")\n @board[input.to_i - 1] = value\n end",
"def main_setter(board, score, gameover)\n @board = board\n @size = 4\n @score = score\n @gameover = gameover\n end",
"def update_board(move)\n for i in 0...@board.length\n if move == @board[i]\n # replaces number with either X or O\n @board[i] = @taken[move]\n end\n end\n end",
"def move(board, position, current_player= \"X\")\n board[position.to_i - 1] = current_player\nend",
"def place_piece piece_id, r, c\r\n puts \"Placing a #{piece_id} at #{r}, #{c}\"\r\n @board[r][c]= piece_id\r\n end",
"def move(board, index, char = \"X\")\n board[index.to_i] = char\nend",
"def turn\n\t if @player_number % 2 == 0\n\t\t\tputs \"Player X choose your box! 1-9\"\n\t\t\t@ttt.assign_box(gets.chomp.to_i, @x.xoro)\n\t else\n\t\t\tputs \"Player O choose your box! 1-9\"\n\t\t\t@ttt.assign_box(gets.chomp.to_i, @o.xoro)\n\t end \n\tend",
"def update_board(num, sign)\n @squares = @squares.map do |row|\n row.each do |item|\n item.each do |key, _value|\n item[key] = sign if key == :\"#{num}\"\n end\n end\n end\n\n show_board\n end",
"def []=(row, column, value)\n puzzle[row][column] = value\n end",
"def transfer_card_num(pick_num)\n num = pick_num % 13\n case num\n when 0\n 'A'\n when 10\n 'J'\n when 11\n 'Q'\n when 12\n 'K'\n else\n num + 1\n end\n end",
"def set_board\n if params[:id].present?\n @board = Board.find(params[:id])\n else\n @user = User.find_by_username(params[:username])\n @board = Board.find_by_user_id_and_board_slug(@user.id, params[:board_slug])\n end\n end",
"def move (board, index, value = \"X\")\n #binding.pry\n board[index] = value\nend",
"def move(index, current_player = \"X\")\n @board[index] = current_player\nend",
"def set_cell_number\n @cell_number = CellNumber.find(params[:id])\n end",
"def update_cell_status(turn_number,choice)\n\t\tif turn_number%2!=0 then\n\t\t\tchoice_value=1\n\t\telse\n\t\t\tchoice_value=2\n\t\tend\n\t\t@cell_status[choice]=choice_value\n\tend",
"def move(board, input, team = \"X\")\n board[input.to_i - 1] = team\n return board\nend",
"def move(board, position, value = \"X\")\n\n board[position.to_i - 1] = value\n\n return board\nend",
"def next_move\n\n @board.board[@choice] = id\n @board.free.delete(@choice)\n p self\n puts \"player #{id + 1} chooses #{@choice}\"\n puts @board\n\n @board.winner || @board.free.empty?\n end",
"def []=(pos, num)\n row, col = pos\n @partial[row][col] = num\n end"
] |
[
"0.72061247",
"0.6614173",
"0.6608064",
"0.65731436",
"0.6559795",
"0.65297574",
"0.64886427",
"0.6485483",
"0.64492375",
"0.6421589",
"0.64139074",
"0.63991094",
"0.63991094",
"0.6387553",
"0.63794553",
"0.6378448",
"0.6338022",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.633373",
"0.63173",
"0.63125336",
"0.63097066",
"0.6298639",
"0.6282011",
"0.6281335",
"0.6263888",
"0.6255237",
"0.62377876",
"0.62072694",
"0.6203615",
"0.61994016",
"0.6199058",
"0.6183892",
"0.6165938",
"0.61558825",
"0.61511725",
"0.6150651",
"0.61364657",
"0.61364657",
"0.61364657",
"0.613636",
"0.61204743",
"0.61113787",
"0.6109894",
"0.61091965",
"0.60982364",
"0.60889095",
"0.60857624",
"0.6056404",
"0.60302514",
"0.6019418",
"0.60174465",
"0.60100377",
"0.5991576",
"0.5991576",
"0.59915257",
"0.59864974",
"0.5967801",
"0.59522957",
"0.5950485",
"0.59465003",
"0.59250367",
"0.59215313",
"0.59142506",
"0.5906303",
"0.5902589",
"0.5890017",
"0.5880765",
"0.5875932",
"0.5865539",
"0.5855228",
"0.58550245",
"0.58538485",
"0.5852667",
"0.58497965",
"0.584241",
"0.5840659",
"0.583584",
"0.5825646",
"0.5824351",
"0.58144057",
"0.5814099",
"0.5804913"
] |
0.7860766
|
0
|
String (the op to perform) outputs: Integer (the result of the op) reqs: implement a stack using push and pop methods use a 'register' to rep the current value for a given op, pop most recently pushed value from the stack, perform the op on that and the the register value, and store the result in the register all ops are integer based take a str as an arg (spec'ing the operands and the ops to perform) init the reg to 0 rules: none struct: arr (to hold list of cmds) algo: init a reg (int) to 0 init a stack (array) of ints to [] split the cmd str into an arr of cmds for each cmd perform the spec'd op n Place a value n in the "register". Do not modify the stack. PUSH Push the register value on to the stack. Leave the value in the register. ADD Pops a value from the stack and adds it to the register value, storing the result in the register. SUB Pops a value from the stack and subtracts it from the register value, storing the result in the register. MULT Pops a value from the stack and multiplies it by the register value, storing the result in the register. DIV Pops a value from the stack and divides it into the register value, storing the integer result in the register. MOD Pops a value from the stack and divides it into the register value, storing the integer remainder of the division in the register. POP Remove the topmost item from the stack and place in register PRINT Print the register value
|
def minilang(str)
stack = []
reg = 0
# puts str
cmds = str.split
cmds.each do |cmd|
# puts "cmd == #{cmd}"
case cmd
when 'PUSH' then stack << reg
when 'ADD' then reg += stack.pop
when 'SUB' then reg -= stack.pop
when 'MULT' then reg *= stack.pop
when 'DIV' then reg /= stack.pop
when 'MOD' then reg %= stack.pop
when 'POP' then reg = stack.pop
when 'PRINT' then puts reg
else reg = cmd.to_i # integer
end
end
puts
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def arithmeticBinary(op)\n str = getTopTwoFromStack + \"M=M\"+op+\"D\"+\"\\n\"\n return str+\"\\n\"\nend",
"def stackEval(cmdStack, resStack, memState)\n # cmdStack => the command stack implemented using a list\n # resStack => the results stack implemented using a list\n # memState => the memory state implemented using a block. Will contain a map for variable names and their integers\n\n # create a map to convert vals in resStack to actual operators\n # stack will be an array where elements are added to front and removed from front\n i = 0\n while true do\n if cmdStack.length == 0\n break\n end\n if cmdStack[0].is_a?(GCConst)\n #puts \"const\"\n #puts cmdStack[0].value\n # add constants from control stack to results stack\n resStack.unshift(cmdStack[0].value) # puts the value from cmdStack[i] into the start of resStack\n cmdStack = cmdStack.drop(1) # remove top value (index 0) from command stack\n i += 1\n elsif cmdStack[0].is_a?(GCTrue)\n # add booleans from control stack to results stack\n resStack.unshift(cmdStack[0].value) # puts the value from cmdStack[i] into the start of resStack\n cmdStack = cmdStack.drop(1)\n i += 1 \n elsif cmdStack[0].is_a?(GCFalse)\n # add booleans from control stack to results stack\n resStack.unshift(cmdStack[0].value) # puts the value from cmdStack[i] into the start of resStack\n cmdStack = cmdStack.drop(1)\n i += 1\n elsif cmdStack[0].is_a?(GCOp)\n #puts \"op\"\n a = cmdStack[0]\n cmdStack = cmdStack.drop(1) \n cmdStack.unshift(a.op) #add operator to the stack\n cmdStack.unshift(a.e2) # add second expr to cmdStack\n cmdStack.unshift(a.e1) # add first expr to cmdStack\n i += 1\n\n # binary operators on cmd stack\n elsif cmdStack[0] == :plus\n b = resStack[0] # get first value from resStack. This will be the second expr in the operator statement\n resStack = resStack.drop(1)\n a = resStack[0] # get next value from resStack. This will be the first expr in the operator statement\n resStack = resStack.drop(1)\n resStack.unshift(a + b) #apply operator and put it back on resStack\n cmdStack = cmdStack.drop(1)\n i += 1\n elsif cmdStack[0] == :minus\n b = resStack[0]\n resStack = resStack.drop(1)\n a = resStack[0]\n resStack = resStack.drop(1)\n resStack.unshift(a - b)\n cmdStack = cmdStack.drop(1)\n i += 1\n elsif cmdStack[0] == :times\n b = resStack[0]\n resStack = resStack.drop(1)\n a = resStack[0]\n resStack = resStack.drop(1)\n resStack.unshift(a * b)\n cmdStack = cmdStack.drop(1)\n i += 1\n elsif cmdStack[0] == :div\n b = resStack[0]\n resStack = resStack.drop(1)\n a = resStack[0]\n resStack = resStack.drop(1)\n resStack.unshift(a / b)\n cmdStack = cmdStack.drop(1)\n i += 1\n\n # variable\n elsif cmdStack[0].is_a?(GCVar)\n # apply memoryState function to variable and add to resultStack\n\n x = memState.call(cmdStack[0].value)\n #puts \"var\"\n #puts x\n resStack.unshift(memState.call(cmdStack[0].value))\n # remove GCVar from commandstack\n cmdStack = cmdStack.drop(1)\n i += 1\n\n # Test compare\n elsif cmdStack[0].is_a?(GCComp)\n #puts \"comp\"\n a = cmdStack[0]\n cmdStack = cmdStack.drop(1)\n cmdStack.unshift(a.op) #add operator to the stack\n cmdStack.unshift(a.e2) # add second expr to cmdStack\n cmdStack.unshift(a.e1) # add first expr to cmdStack\n i += 1 \n\n # less\n elsif cmdStack[0] == :less\n #puts \"less\"\n a = resStack[1]\n b = resStack[0]\n resStack = resStack.drop(2)\n resStack.unshift(a < b)\n cmdStack = cmdStack.drop(1)\n\n # greater\n elsif cmdStack[0] == :greater\n a = resStack[1]\n b = resStack[0]\n #puts \"greater\"\n resStack = resStack.drop(2)\n resStack.unshift(a > b)\n cmdStack = cmdStack.drop(1)\n\n # eq\n elsif cmdStack[0] == :eq\n a = resStack[0]\n b = resStack[1]\n resStack = resStack.drop(2)\n resStack.unshift(a == b)\n cmdStack = cmdStack.drop(1)\n\n elsif cmdStack[0].is_a?(GCAnd)\n #puts \"and gc\"\n a = cmdStack[0]\n cmdStack = cmdStack.drop(1)\n cmdStack.unshift(\"and\")\n cmdStack.unshift(a.t2)\n cmdStack.unshift(a.t1)\n\n elsif cmdStack[0] == \"and\"\n a = resStack[0]\n b = resStack[1]\n #puts a&b\n resStack = resStack.drop(2)\n cmdStack = cmdStack.drop(1)\n resStack.unshift(a & b)\n\n elsif cmdStack[0].is_a?(GCOr)\n a = cmdStack[0]\n cmdStack = cmdStack.drop(1)\n cmdStack.unshift(\"or\")\n cmdStack.unshift(a.t2)\n cmdStack.unshift(a.t1)\n\n elsif cmdStack[0] == \"or\"\n a = resStack[0]\n b = resStack[1]\n resStack = resStack.drop(2)\n cmdStack.drop(1)\n resStack.unshift(a | b)\n\n\n\n # skip\n elsif cmdStack[0].is_a?(GCSkip)\n # no changes to result stack or memState\n cmdStack = cmdStack.drop(1)\n break\n i += 1\n\n # variable assignment\n elsif cmdStack[0].is_a?(GCAssign)\n # add to memState the new variable substitution \n #puts \"assign\"\n a = cmdStack[0]\n cmdStack = cmdStack.drop(1) # remove GCAssign from cmdstack\n cmdStack.unshift(a.s) # add symbol to be assigned\n cmdStack.unshift(\"assign\") # add assign statement\n cmdStack.unshift(a.e) # add expression to be evaluated\n i += 1\n \n #assignment operator\n # command stack [\"assign\",symbol,...]\n # res stack [const,...]\n elsif cmdStack[0] == \"assign\"\n memState = updateState(memState, cmdStack[1], resStack[0])\n cmdStack = cmdStack.drop(2) # remove assign and symbol\n resStack = resStack.drop(1) # remove constant \n i += 1\n\n # compose\n elsif cmdStack[0].is_a?(GCCompose)\n #puts \"compose\"\n a = cmdStack[0]\n cmdStack = cmdStack.drop(1) # remove GCCompose from command stack\n cmdStack.unshift(a.st2) # add 2nd statement to be evaluated\n cmdStack.unshift(a.st1) # add first statement to be evaluated\n i += 1\n\n # if statement breakdown\n elsif cmdStack[0].is_a?(GCIf)\n p = cmdStack[0] # top element from stack. Should be of type GCIf\n cmdStack = cmdStack.drop(1) #remove GCIf from cmdStack\n l = p.pairlist # get list from GCIf\n if l.length == 0\n cmdStack.unshift(GCSkip.new())\n else\n randval = rand(l.length) # get random value \n pair = l[randval]\n l.delete_at(randval) # remove statement from index randval\n \n # re-add broken down GCIf to command stakc\n cmdStack.unshift(GCIf.new(l)) # add remaining statements\n cmdStack.unshift(pair[1]) # add statement \n cmdStack.unshift(\"if\") # add if\n cmdStack.unshift(pair[0]) # add boolean guard\n i += 1\n end\n elsif cmdStack[0] == \"if\"\n b = resStack[0] # get the boolean that would have been evaluated from result stack\n if b == true \n s1 = cmdStack[1] # get the statement to be executed\n cmdStack = cmdStack.drop(3) # remove the if, s1 and remaining GCIf block \n resStack = resStack.drop(1) # remove that boolean check\n cmdStack.unshift(s1) #place the s1 value back on command stack\n else \n cmdStack = cmdStack.drop(2) # remove \"if\" and s1. The top element on stack should now be the remaining GCIf statements \n resStack = resStack.drop(1) # remove the boolean \n end\n\n # while loop\n # logic: get random statement from list and place it at top of command stack\n # check if the guard is true. If so then do that statement and repeat\n # if false, can either find another statement or do nothing\n # in this implementation, I will do nothing in the false case\n elsif cmdStack[0].is_a?(GCDo)\n #puts \"do\"\n w = cmdStack[0] # get Do statement off command stack\n #cmdStack = cmdStack.drop(1) # remove statement\n #cmdStack.unshift(GCDo.new(w.pairlist)) \n if w.pairlist.length == 0 # if no pairs, do nothing\n cmdStack.unshift(GCSkip.new())\n else\n randval = rand(w.pairlist.length) # get random value\n pair = w.pairlist[randval] # get random pair\n cmdStack = cmdStack.drop(1) # remove GCDo\n cmdStack.unshift(pair[1]) # add statement\n cmdStack.unshift(pair[0]) # add boolean check\n cmdStack.unshift(\"while\")\n cmdStack.unshift(pair[0]) # condition\n i += 1\n # command stack should look like [guard, \"while\", guard, statement, ...]\n end\n elsif cmdStack[0] == \"while\"\n # command stack will be in form [\"while\", guard, statement, ...]\n # resStack will be in form [true/false, ...]\n b = resStack[0] # check evaluated condition\n g = cmdStack[1] # guard\n s = cmdStack[2] # statement \n if b == true\n cmdStack.unshift(g) # place guard to front of stack\n cmdStack.unshift(s) # place statement to front of stack to be evaluated\n resStack = resStack.drop(1) # remove previously evaluated condition\n # new command stack will be in form [statement, guard, \"while\", guard, statement]\n else\n #puts \"while guard was false\"\n cmdStack.drop(3) #remove while, guard and statement from command stack\n cmdStack.unshift(GCSkip.new()) #end loop\n resStack = resStack.drop(1) # remove previously computed bool\n i += 1\n end\n else \n puts \"Invalid input\"\n break\n end\n end\n return memState \n\n end",
"def eval_math(string)\n number_stack = []\n operator_stack = []\n tokens = string.split(\" \")\n tokens.each_with_index do |n, i|\n if n == \"*\" \n number_stack << number_stack.pop.to_i * tokens[i+1].to_i\n tokens.delete_at(i+1)\n elsif n == \"/\" \n number_stack << number_stack.pop.to_i / tokens[i+1].to_i\n tokens.delete_at(i+1)\n elsif ['+','-'].include? n\n operator_stack << n\n else\n number_stack << n\n end\n puts \"evaling n: #{n}, number_stack #{number_stack} operator_stack #{operator_stack}\"\n end\n result = 0\n operator_stack.each do |o|\n if o == '+'\n number_stack[0] = number_stack.first.to_i + number_stack.delete_at(1).to_i\n end\n if o == '-'\n number_stack[0] = number_stack.first.to_i - number_stack.delete_at(1).to_i\n end\n end\n\n return number_stack[0]\n\nend",
"def math_eval(str)\n # iterate over string values\n # perhaps utilize a queue till you hit a symbol?\n # left operand and right operand (do we care about order of operations?)\n copy = str\n total = 0\n tokens = []\n\n copy.chars.each_with_index do |ch, idx|\n if ch == '*' || ch == '/' || ch == '+' || ch == '-'\n divided = str.split(ch)\n tokens << divided.shift.to_i\n tokens << ch\n copy = divided\n end\n if idx == copy.length - 1\n tokens << copy\n end\n # break if ch.match(/()+\\-*/) && operator != ''\n # operator = ch.match(/()+\\-*/)\n # left_operand = ch if ch.match(/0-9/) && operator == ''\n # right_operand += ch if ch.match(/0-9/) && operator != ''\n end\n return tokens\n\n p \"operator: #{operator}, left_operand: #{left_operand}, right_operand: #{right_operand}\"\n return left_operand.to_i if operator == ''\n return left_operand.to_i + right_operand.to_i if operator == '+'\n return left_operand.to_i - right_operand.to_i if operator == '-'\n return left_operand.to_i / right_operand.to_i if operator == '/'\n return left_operand.to_i * right_operand.to_i if operator == '*'\nend",
"def minilang(command_string)\n stack = []\n register = 0\n command_string.split(' ').each do |command|\n case command\n when 'PUSH' then stack << register\n when 'ADD' then register += stack.pop\n when 'SUB' then register -= stack.pop\n when 'MULT' then register *= stack.pop\n when 'DIV' then register /= stack.pop\n when 'MOD' then register %= stack.pop\n when 'POP' then register = stack.pop\n when 'PRINT' then puts register\n else register = command.to_i\n end\n end\n register\nend",
"def arithmeticUnary(op)\n str = getTopOfStack + \"M=\"+op+\"M\"+\"\\n\"\n return str+\"\\n\"\nend",
"def minilang(commands)\n stack = []\n register = 0\n command_arr = commands.split\n\n command_arr.each do |command|\n case command\n when \"PUSH\"\n stack.push(register)\n when \"ADD\"\n register += stack.pop\n when \"SUB\"\n register -= stack.pop\n when \"MULT\"\n register *= stack.pop\n when \"DIV\"\n if stack.last == 0\n puts \"Divide by zero error. Can't perform \\\"DIV\\\" command.\"\n else\n register /= stack.pop\n end\n when \"MOD\"\n if stack.last == 0\n puts \"Divide by zero error. Can't perform \\\"MOD\\\" command.\"\n else\n register %= stack.pop\n end\n when \"POP\"\n register = stack.pop\n when \"PRINT\"\n puts register\n else\n register = command.to_i\n end\n end\nend",
"def minilang(str)\n stack = []\n reg = 0\n \n commands = str.split(' ')\n \n commands.each {|command|\n case command\n when 'PRINT'\n puts reg\n when 'PUSH'\n stack.push(reg)\n when 'POP'\n reg = stack.pop\n when 'ADD'\n reg += stack.pop \n when 'SUB'\n reg -= stack.pop \n when 'MULT'\n reg *= stack.pop \n when 'DIV'\n reg /= stack.pop \n when 'MOD'\n reg %= stack.pop\n else\n reg = command.to_i\n end\n }\nend",
"def minilang(program_str)\n register = 0\n stack = []\n commands = program_str.split(' ')\n\n commands.each do |command|\n case command\n when 'PUSH' then stack << register\n when 'ADD' then register += (stack.pop).to_i\n when 'SUB' then register -= (stack.pop).to_i\n when 'MULT' then register *= (stack.pop).to_i\n when 'DIV' then register /= (stack.pop).to_i\n when 'MOD' then register %= (stack.pop).to_i\n when 'POP' then register = (stack.pop).to_i\n when 'PRINT' then puts register\n else register = command.to_i\n end\n end\nend",
"def minilang(string)\n register = 0\n stack = []\n\n string.split(' ').each do |cmd|\n case cmd\n when 'PUSH' then stack.push(register)\n when 'ADD' then register += stack.pop.to_i\n when 'SUB' then register -= stack.pop.to_i\n when 'MULT' then register *= stack.pop.to_i\n when 'DIV' then register /= stack.pop.to_i\n when 'MOD' then register %= stack.pop.to_i\n when 'POP' then register = stack.pop.to_i\n when 'PRINT' then puts register\n else register = cmd.to_i\n end\n end\nend",
"def minilang(string)\n register = 0\n stack = []\n string.split.each do |command|\n case command\n when \"PUSH\" then stack << register\n when \"ADD\" then register += stack.pop\n when \"SUB\" then register -= stack.pop\n when \"MULT\" then register *= stack.pop\n when \"DIV\" then register /= stack.pop\n when \"MOD\" then register %= stack.pop\n when \"POP\" then register = stack.pop\n when \"PRINT\" then puts register\n else register = command.to_i\n end\n end\nend",
"def minilang(command_string)\n command_array = command_string.split\n register = 0\n stack = []\n counter = 0\n until counter > command_array.size do\n if is_string_int?(command_array[counter])\n register = command_array[counter].to_i\n else\n case command_array[counter]\n when 'PUSH' then stack << register\n when 'ADD' then register += stack.pop\n when 'SUB' then register -= stack.pop\n when 'MULT' then register *= stack.pop\n when 'DIV' then register /= stack.pop\n when 'MOD' then register %= stack.pop\n when 'POP' then register = stack.pop\n when 'PRINT' then puts register\n end\n end\n counter += 1\n end\nend",
"def convertArithmetic(op)\n case op\n\n #basic arithmetic operations\n when \"add\"\n cmds = \"//add\"+\"\\n\" + arithmeticBinary(\"+\")\n\n when \"sub\"\n cmds = \"//subtract\"+\"\\n\" +arithmeticBinary(\"-\")\n\n when \"neg\"\n cmds = \"//negate\" +\"\\n\"+arithmeticUnary(\"-\")\n\n #basic bitwise operations\n when \"and\"\n cmds = \"//and\" +\"\\n\"+arithmeticBinary(\"&\")\n\n when \"or\"\n cmds = \"//or\" +\"\\n\"+arithmeticBinary(\"|\")\n\n when \"not\"\n cmds = \"//not\" +\"\\n\"+arithmeticUnary(\"!\")\n else\n cmds = \"//not a legal command\"\n end\n\n return cmds\nend",
"def writeArithmetic(command)\n assembly_builder = []\n # Add\n if command == 'add'\n assembly_builder.push(\n '@SP',# A=0\n 'AM=M-1',# A=RAM[0]=M[0]-1\n 'D=M',# D=RAM[257]\n 'A=A-1',# A=257-1=256\n 'M=M+D'# RAM[256]=RAM[256]+D\n )\n\n elsif command == 'sub'\n assembly_builder.push(\n '@SP',\n 'AM=M-1',\n 'D=M',\n 'A=A-1',\n 'M=M-D'\n )\n\n # y = -y\n elsif command == 'neg'\n assembly_builder.push(\n '@SP',\n 'A=M-1',\n 'M=-M',\n )\n\n # x == y ? -1 : 0\n elsif command == 'eq'\n assembly_builder.push(\n '@SP',\n 'AM=M-1', # M = 257\n 'D=M', # D = 4\n 'A=A-1', # @256\n 'D=M-D', # D = 5 - 4 = 1\n 'M=-1', # M[256] = -1\n '@EQEND', # if D == 0 → EQEND\n 'D;JEQ', #\n '@SP',\n 'A=M-1',\n 'M=0',\n '(EQEND)'\n )\n\n # x > y ? -1 : 0\n elsif command == 'gt'\n assembly_builder.push(\n '@SP',\n 'AM=M-1', # M = 257\n 'D=M', # D = 4\n 'A=A-1', # @256\n 'D=M-D', # D = 5 - 4 = 1\n 'M=-1', # M[256] = -1\n '@GTEND', # if D == 0 → EQEND\n 'D;JGT', #\n '@SP',\n 'A=M-1',\n 'M=0',\n '(GTEND)'\n )\n # x < y ? -1 : 0\n elsif command == 'lt'\n assembly_builder.push(\n '@SP',\n 'AM=M-1', # M = 257\n 'D=M', # D = 4\n 'A=A-1', # @256\n 'D=M-D', # D = 5 - 4 = 1\n 'M=-1', # M[256] = -1\n '@LTEND', # if D == 0 → EQEND\n 'D;JLT', #\n '@SP',\n 'A=M-1',\n 'M=0',\n '(LTEND)'\n )\n # x & y\n elsif command == 'and'\n assembly_builder.push(\n '@SP',\n 'AM=M-1', # M = 257\n 'D=M', # D = 4\n 'A=A-1', # @256\n 'M=D&M'\n )\n # x | y\n elsif command == 'or'\n assembly_builder.push(\n '@SP',\n 'AM=M-1', # M = 257\n 'D=M', # D = 4\n 'A=A-1', # @256\n 'M=D|M'\n )\n # not y\n elsif command == 'not'\n assembly_builder.push(\n '@SP',\n 'A=M-1', # M = 257\n 'M=!M'\n )\n end\n return assembly_builder\n end",
"def evaluate_with_two_stacks(string)\n vals = Stack.new\n ops = Stack.new\n\n string.each_char do |char|\n case char\n when \"(\"\n # do nothing\n when \"+\"\n ops.push(char)\n when \"*\"\n ops.push(char)\n when \")\"\n op = ops.pop\n case op\n when \"+\"\n vals.push(vals.pop + vals.pop)\n when \"*\"\n vals.push(vals.pop * vals.pop)\n end\n else\n vals.push(char.to_i)\n end\n end\n\n vals.pop\nend",
"def minilang(str)\n register = 0\n stack = []\n\n command = str.split(' ')\n command.map! { |element| element.to_i.to_s == element ? element.to_i : element }\n p command\n\n command.each do |element|\n case element\n when 'PUSH'\n stack.push(register)\n when 'ADD'\n register += stack.pop\n when 'SUB'\n register -= stack.pop\n when 'MULT'\n register *= stack.pop\n when 'DIV'\n register /= stack.pop\n when 'MOD'\n register %= stack.pop\n when 'POP'\n register = stack.pop\n when 'PRINT'\n puts register\n else\n register = element\n end\n end\nend",
"def calculator(op, num1, num2)\n if op == \"add\" || op == \"+\" || op == \"addition\"\n return num1 + \" + \" + num2 + \" = #{add(num1.to_i, num2.to_i)}\"\n elsif op == \"subtract\" || op == \"-\" || op == \"subtraction\"\n return num1 + \" - \" + num2 + \" = #{sub(num1.to_i, num2.to_i)}\"\n elsif op == \"multiply\" || op == \"*\" || op == \"multiplication\"\n return num1 + \" * \" + num2 + \" = #{mult(num1.to_i, num2.to_i)}\"\n elsif op == \"divide\" || op == \"/\" || op == \"division\"\n return num1 + \" / \" + num2 + \" = #{div(num1.to_i, num2.to_i)}\"\n elsif op == \"modulo\" || op == \"remainder\" || op == \"%\"\n return num1 + \" % \" + num2 + \" = #{mod(num1.to_i, num2.to_i)}\"\n else op == \"exponent\" || op == \"^\"\n return num1 + \"^\" + num2 + \" = #{exponent(num1.to_i, num2.to_i)}\"\n end\nend",
"def solution(s)\n stack = []\n s.split(' ').each do |input|\n case input\n when POP_COMMAND\n entry = stack.pop()\n raise InvalidOperation, 'Empty Stack' if entry == nil\n when DUPLICATE_COMMAND\n entry = stack.pop()\n raise InvalidOperation, 'Empty Stack' if entry == nil\n stack.push(entry)\n stack.push(entry)\n when ADDITION_COMMAND\n first = stack.pop()\n second = stack.pop()\n raise InvalidOperation, 'Empty Stack' if first == nil || second == nil\n raise InvalidOperation, 'Overflow Integer' if (first > UNSIGNED_INTEGER_LIMIT - second)\n stack.push(first + second)\n when SUBTRACTION_COMMAND\n first = stack.pop()\n second = stack.pop()\n raise InvalidOperation, 'Empty Stack' if first == nil || second == nil\n raise InvalidOperation, 'Negative value' if (first < second)\n stack.push(first - second)\n else\n stack.push(Integer(input))\n end\n end\n\n raise InvalidOperation, 'Empty Stack' if stack.length == 0\n stack.pop()\nend",
"def calculate(input)\n raise error(\"length is zero!\") unless input.length > 0\n # break input string on whitespace for tokens.\n tokens = input.strip.gsub(/\\(|\\)/,'').split(/\\s+/m)\n tokens.each_with_index do |token, index|\n raise error(\"syntax error at token ##{index + 1} '#{token}'\") unless token =~ /\\d+|[*-\\/+^%]/\n # if this is an operand, add it to the stack\n if token =~ /\\d/\n @stack << token.to_f\n else\n raise error(\"not enough operands at token ##{index + 1} '#{token}'\") if (@stack.length < MIN_TOKENS && @strict)\n # if it is an operator, take the operands off the stack and apply the operator to them\n while @stack.length > 1\n first, second = @stack.pop(MIN_TOKENS)\n @stack << first.send(token, second)\n end\n end\n end\n raise error(\"invalid syntax\") unless @stack.length == 1\n @stack.pop\n end",
"def check_op (oper)\n if oper == 'add' || oper == '+'\n puts \"+ + Let's add 'em up! + +\"\n return operator = '+'\n elsif oper == 'subtract' || oper == '-'\n puts \"- - Let's subtract! - -\"\n return operator = '-'\n elsif oper == 'multiply' || oper == '*'\n puts \"* * It's time to multiply! * *\"\n return operator = '*'\n elsif oper == 'divide' || oper == '/'\n puts \"/ / Let's divide 'em up! / /\"\n return operator = '/'\n elsif oper == 'exponent' || oper == '**'\n puts \"^ ^ Let's power 'em up! ^ ^\"\n return operator = '**'\n elsif oper == 'remainder' || oper == '%'\n puts \"% % Let's find the remainder! % %\"\n return operator = '%'\n end\nend",
"def rpn(operation)\n rpn_stack = Stack.new\n tokens = parse_tokens(operation)\n puts tokens.to_s\n tokens.each do |token|\n if !is_operator?(token)\n puts \"pushing token #{token}\"\n rpn_stack.push(token)\n else\n val2 = rpn_stack.pop\n val1 = rpn_stack.pop\n rpn_stack.push(calculate(val1,val2, token))\n end # end of if\n end # end of each\n rpn_stack.pop\nend",
"def writeArithmetic(command)\n\t\tif command == \"add\"\n pop()\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M+D\\n\")\n elsif command == \"sub\"\n pop()\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M-D\\n\") \n elsif command == \"neg\"\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=-M\\n\")\n elsif command == \"and\"\n pop()\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M & D\\n\")\n elsif command == \"or\"\n pop()\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M | D\\n\")\n elsif command == \"not\"\n pop()\n @file.write(\"@SP\\n\")\n @file.write(\"A=M\\n\")\n @file.write(\"M=!D\")\n elsif command == \"eq\"\n label = \"negate\" + @counter.to_s\n\t\t\t@counter += 1\n pop()\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"D=M-D\\n\")\n @file.write(\"@\" + label + \"\\n\")\n @file.write(\"D;JEQ\\n\")\n @file.write(\"D=1\\n\")\n @file.write(\"(\" + label + \")\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=!D\\n\")\n elsif command == \"lt\"\n glJump(\"JLT\")\n elsif command == \"gt\"\n glJump(\"JGT\")\n\t\tend\n\tend",
"def get_result(operator, *n)\n return $operations[operator].call(*n).to_s\nend",
"def calculate(op1, operator, op2)\n\tstring = op1.to_s + operator + op2.to_s\n\n\t# operator is assumed to be a string; \n\t# make one big string of it and the two operands \n\teval(string) # evaluate and return a value - never use eval ! eval is EVIL lol \nend",
"def evaluate() \n # operand stack\n opStack = []\n \n # iterate over the tokens\n @postfix.split(\"\").each do |c|\n # check if an operator\n if %w[+ - * / ^].include? c\n # pop the stack for the two operands where\n # a [operator] b\n b, a = opStack.pop, opStack.pop\n \n # evaluate the string as an arithmetic expression\n # replace all '^' characters with '**' operator\n opStack.push(eval(\"(#{a})#{c}(#{b})\".gsub(/\\^/,'**')))\n else\n # push any operands onto stack\n opStack.push(c)\n end\n end\n \n # Last item in stack should be the final answer!\n opStack.pop\n end",
"def _calc operator\n (operand1, operand2) = @stack.pop 2\n @stack.unshift @stack.first\n @stack.push operand1.send(operator.to_sym, operand2)\nend",
"def evaluate(ops)\n \t\tops = tokens(ops)\n \t\tmethods = {:+ => Proc.new{plus()}, :- => Proc.new{minus()}, :* => Proc.new{times()}, :/ => Proc.new{divide()}}\n \t\tops.each do |op|\n \t\t\tif methods.has_key?(op)\n \t\t\t\tmethods[op].call\n \t\t\telse\n \t\t\t\tpush(op)\n \t\t\tend\n \t\tend\n \t\tvalue()\n end",
"def tokens(ops)\n \t\toperators = {\"+\" => :+, \"-\" => :-, \"*\" => :*, \"/\" => :/}\n \t\tops = ops.split(\" \")\n \t\ttokenized = []\n \t\tops.each do |op|\n \t\t\tif operators.has_key?(op)\n \t\t\t\ttokenized << operators[op]\n \t\t\telse\n \t\t\t\ttokenized << op.to_i\n \t\t\tend\n \t\tend\n \t\ttokenized\n end",
"def writeArithmetic(cmd,ln)\n\tcase cmd[:c]\n\twhen 'add','sub','and','or' then l = arith(cmd[:s])\n\twhen 'neg','not' then l = neginv(cmd[:s])\n\twhen 'gt','lt','eq' then l = glte(cmd[:s],ln)\n\telse return -1 end \n\treturn l\nend",
"def evalRPN(exp)\n begin\n expr = parseString(exp) # Parse expression into array\n\n stack = Stack.new # stack to keep track of operands\n\n # convert string to int or float\n case expr[0]\n when /\\.{1}/\n stack.push(atof(expr[0]))\n else\n stack.push(atoi(expr[0]))\n end\n\n for i in 1..expr.length\n\n # Addition - perform addition on previous two operands\n if expr[i] == '+' \n stack.push(calc stack.pop, stack.pop, &:+)\n\n # Subtraction - perform subtraction on previous two operands\n elsif expr[i] == '-'\n stack.push(calc stack.pop, stack.pop, &:-) \n\n # Division - perform division on previous two operands\n elsif expr[i] == '/'\n stack.push(calc (stack.pop/1.0), stack.pop, &:/)\n\n # Multiplication - perform mult on previous two operands\n elsif expr[i] == '*'\n stack.push(calc stack.pop, stack.pop, &:*)\n\n # Just a number -- add to stack\n else\n next if expr[i] == nil # dont add nil to stack\n\n case expr[i]\n when /\\.{1}/\n stack.push(atof(expr[i]))\n else\n stack.push(atoi(expr[i]))\n end\n end\n end\n\n # No operator provided\n raise NotEnoughException if stack.size != 1\n \n return stack.pop # Return answer\n\n rescue NotEnoughException => e\n abort(e.mes) # inform user of error\n end\n\nend",
"def calc_operator token\n ##\n # We need two operands to perform an operation, so we \n # raise `InvalidTokenError` if we don't have those \n # (as at that moment of execution operator-tokens are invalid).\n raise InvalidTokenError if @stack.length < 2\n arg2 = pop!\n arg1 = pop!\n res = get_operation(token).call(arg1, arg2)\n @stack.push(res)\n res\n end",
"def minilang(str)\n register = 0\n stack = []\n\n str.split.each do |el|\n case \n when el == 'ADD' then register += stack.pop\n when el == 'SUB' then register -= stack.pop\n when el == 'MULT' then register *= stack.pop\n when el == 'DIV' then register /= stack.pop \n when el == 'MOD' then register %= stack.pop \n when el == 'PUSH' then stack.push(register)\n when el == 'POP' then register = stack.pop \n when el == 'PRINT' then puts register \n else register = el.to_i\n end\n end\nend",
"def minilang(program)\n stack = []\n register = 0\n commands = program.split\n commands.each do |command|\n case command\n when 'PUSH' then stack << register\n when 'ADD' then register += stack.pop\n when 'SUB' then register -= stack.pop\n when 'MULT' then register = register * stack.pop\n when 'DIV' then register = register / stack.pop\n when 'MOD' then register = register % stack.pop\n when 'POP' then register = stack.pop\n when 'PRINT' then puts register\n else register = command.to_i\n end\n end\n nil\nend",
"def writeArithmetic(command)\n\t\tif command == \"add\"\n pop()\n\t\t\t@file.write(\"//writing addition\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M+D\\n\")\n elsif command == \"sub\"\n pop()\n\t\t\t@file.write(\"//writting subtraction\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M-D\\n\") \n elsif command == \"neg\"\n\t\t\t@file.write(\"//negating\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=-M\\n\")\n elsif command == \"and\"\n pop()\n\t\t\t@file.write(\"//writing and\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M & D\\n\")\n elsif command == \"or\"\n pop()\n\t\t\t@file.write(\"//writing or\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=M | D\\n\")\n elsif command == \"not\"\n\t\t\t@file.write(\"//writing not\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=!M\\n\")\n elsif command == \"eq\"\n label = \"negate\" + @counter.to_s\n\t\t\t@counter += 1\n pop()\n\t\t\t@file.write(\"//eq\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"D=M-D\\n\")\n @file.write(\"@\" + label + \"\\n\")\n @file.write(\"D;JEQ\\n\")\n @file.write(\"D=1\\n\")\n @file.write(\"(\" + label + \")\\n\")\n @file.write(\"@SP\\n\")\n @file.write(\"A=M-1\\n\")\n @file.write(\"M=!D\\n\")\n elsif command == \"lt\"\n glJump(\"JLT\")\n elsif command == \"gt\"\n glJump(\"JGT\")\n\t\tend\n\tend",
"def minilang(string)\n register = 0\n stack = []\n\n operation_array = string.downcase.split\n\n operation_array.map!{ |x| x.to_i == 0 ? x : x.to_i }\n\n string.split.size.times do\n register = operation_array.shift if operation_array.first.to_i != 0\n\n case operation_array[0]\n when \"print\"\n p register\n operation_array.shift\n when \"push\"\n stack << register\n operation_array.shift\n when \"mult\"\n register *= stack.pop\n operation_array.shift\n when \"add\"\n register += stack.pop\n operation_array.shift\n when \"pop\"\n register = stack.pop\n operation_array.shift\n when \"div\"\n register /= stack.pop\n operation_array.shift\n when \"mod\"\n register %= stack.pop\n operation_array.shift\n when \"sub\"\n register -= stack.pop\n operation_array.shift\n end\n end\nend",
"def calculator(operator, *numbers)\n result = 0\n if operator == \"*\"\n result = 1\n else\n result = numbers[0]\n numbers.shift\n end\n\n numbers.each do |arg|\n #result = arg operator.send result\n result = result.send(operator,arg)\n end\n return result\nend",
"def operations\n puts \"(a) - addition (+)\"\n puts \"(s) - subtraction (-)\"\n puts \"(m) - multiplication (*)\"\n puts \"(d) - division (/)\"\nend",
"def rpn_calculator\n operators_list = ['+','-','*','/']\n stack = []\n \n def add(stack)\n stack.push(stack.pop + stack.pop)\n end\n \n def minus(stack)\n var1, var2 = stack.pop, stack.pop\n stack.push(var2 - var1)\n end\n \n def multiply(stack)\n stack.push(stack.pop * stack.pop)\n end\n \n def divide(stack)\n stack.push(stack.pop / stack.pop)\n end\n \n def get_user_input\n puts \"enter number or operator into calculator\"\n\n gets.chomp\n end\n \n puts \"enter 'quit' to quit\"\n loop do\n user_choice = get_user_input\n break if user_choice == \"quit\"\n \n if !(operators_list.include?(user_choice))\n stack << user_choice.to_i\n end\n \n case (user_choice)\n when \"+\"\n add(stack)\n when \"-\"\n minus(stack)\n when \"*\"\n multiply(stack)\n when \"/\"\n divide(stack)\n end \n \n \n p stack\n end \nend",
"def test_proper_stack\n stack = TokenStack.new\n stack.push('4')\n stack.push('3')\n stack.push('*')\n terp = Interpreter.new(false, true)\n\n result = terp.binary_operation(0, stack)\n assert_equal 12, result\n end",
"def arithmetic(a, b, operator)\n if operator == \"add\"\n a + b\n elsif operator == \"subtract\"\n a - b\n elsif operator == \"multiply\"\n a * b\n elsif operator == \"divide\"\n a/b\n else\n print \"hahaa\"\n end\nend",
"def calculate str\n ast = parse_expr(str)[1]\n puts ast.to_s\n evaluate_tree(ast)\n end",
"def calculate(operation, n1, n2)\n if operation == \"add\" || operation == \"+\"\n return \"#{n1} + #{n2} = #{n1+n2}\"\n elsif operation == \"subtract\" || operation == \"-\"\n return \"#{n1} - #{n2} = #{n1-n2}\"\n elsif operation == \"multiply\" || operation == \"*\"\n return \"#{n1} * #{n2} = #{n1*n2}\"\n elsif operation == \"divide\" || operation == \"/\"\n if n2 == 0\n return \"undefined\"\n else\n return \"#{n1} / #{n2} = #{n1/n2}\"\n end\n elsif operation == \"exponent\" || operation == \"^\"\n return \"#{n1} ^ #{n2} = #{n1**n2}\"\n elsif operation == \"modulo\" || operation == \"%\"\n return \"#{n1} % #{n2} = #{n1%n2}\"\n end\nend",
"def computer(english)\n operation = english.split(\" \")\n result = NUM_VALUES[operation[0]]\n n = 0\n\n operation.size.times do \n case operation[n]\n when \"plus\"\n result += NUM_VALUES[operation[n + 1]]\n when \"minus\"\n result -= NUM_VALUES[operation[n + 1]]\n end\n n += 1\n end\n\n result\nend",
"def operator_method(string)\n known_operations[string]\n end",
"def opcode(op,args) \"#{op} #{args.join ','}\" end",
"def opcode(op,args) \"#{op} #{args.join ','}\" end",
"def opcode(op,args) \"#{op} #{args.join ','}\" end",
"def opcode(op,args) \"#{op} #{args.join ','}\" end",
"def evaluate\n stack = Stack.new\n\n tokens.each do |token|\n if numeric?(token)\n stack.push(token.to_i)\n elsif operator?(token)\n args = []\n\n (SYMBOL_TABLE[token].arity - 1).times do\n # This adds the return value of stack.pop to the beginning of the\n # args array\n args.unshift(stack.pop)\n end\n\n # The *args syntax might be unfamiliar. It's called the \"splat\"\n # operator and among other things it lets you turn an array into\n # a list of arguments.\n stack.push(call_operator(stack, token, *args))\n else\n stack.push(token)\n end\n end\n\n stack.pop\n end",
"def calculate\n @output << @first << (@op.to_s + @second.to_s)\n \n case @op\n when \"+\" then @result = @first + @second\n when \"-\" then @result = @first - @second\n when \"*\" then \n @result = @first * @second\n # Nasobeni pod sebou ma smysl resit jenom pokud ma druhy citatel vic nez jednu cislici\n if @second.to_s.length > 1\n @output << '-'\n # Iterace pozadu pres druhy citatel pro nasobeni pod sebou\n # Idealne by to zde slo zjednodusit na @second.to_s.reverse.each_char.with_index,\n # ale to jak jsem zjistil neni podporovano v 1.8.x\n @second.to_s.reverse.split(\"\").each_with_index do |char, i|\n @output << (@first * char.to_i).to_s + (' ' * i)\n end \n end\n end\n @output << '-'\n @output << @result\n self # pro zjednoduseni chain callu \n end",
"def stack_eval_infix(string)\n raise \"Bad characters\" if string =~ INVALID_CHARACTERS\n op_stack = LinkedStack.new\n value_stack = LinkedStack.new\n string.chars do | ch |\n case\n when ch =~ /\\d/ || ch == ')'\n if ch == ')'\n raise \"Missing left parenthesis\" if op_stack.empty? || op_stack.top != '('\n op_stack.pop\n else\n value_stack.push(ch.to_i)\n end\n while !op_stack.empty? && op_stack.top =~ OPERATORS\n op = op_stack.pop\n raise \"Missing argument\" if value_stack.empty?\n right_arg = value_stack.pop\n raise \"Missing argument\" if value_stack.empty?\n left_arg = value_stack.pop\n value_stack.push( evaluate(op, left_arg, right_arg) )\n end\n when ch =~ OPERATORS || ch == '('\n op_stack.push(ch)\n end\n end\n raise \"Missing expression\" if value_stack.empty?\n raise \"Too many arguments\" unless value_stack.size == 1\n raise \"Missing argument\" unless op_stack.empty?\n value_stack.pop\nend",
"def get_ops(num)\n operands = Array.new\n while !empty? and !(operands.length >= num)\n operands << pop\n end\n operands.reverse\n end",
"def minilang(str)\n stack = []\n register = 0\n\n str.split.each do |char|\n case char\n when 'PUSH' then stack.push(register)\n when 'ADD' then register += stack.pop\n when 'SUB' then register -= stack.pop\n when 'MULT' then register *= stack.pop\n when 'DIV' then register /= stack.pop\n when 'MOD' then register %= stack.pop\n when 'POP' then register += stack.shift\n when 'PRINT' then puts register\n else register = char.to_i\n end\n end\nend",
"def calculate_answer(operator, a, b)\n\n if operator == \"add\"\n return result= a + b\n elsif operator == \"subtract\"\n return result = a - b\n elsif operator == \"multiply\"\n return result = a * b\n elsif operator == \"divide\"\n return result = a / b\n\nend",
"def calculate\n\t\tplace_in_containers()\n\n\t\t# Checks for mismatch between the number of operands and operators.\n\t\t# The only valid number of operators for N operands is (N - 1).\n\t\tunless @operands.size - @operators.size == 1\n\t\t\t@valid = false\n\t\t\t@errors.push(\"Operand/Operator mismatch.\")\n\t\tend\n\n\t\t# Checks for operators present before the first two operands\n\t\t# are written. This is incorrect RPN syntax.\n\t\tif (@instructions[0..1] & [1010, 1011, 1100, 1101]).any?\n\t\t\t@valid = false\n\t\t\t@errors.push(\"Operator present before first two operands.\")\n\t\tend\n\n\t\t# Checks for an empty operand stack. In this case, there is\n\t\t# nothing more to do in the method.\n\t\tif @operands.empty?\n\t\t\t@errors.push(\"No operands.\")\n\t\t\treturn [0, false]\n\t\tend\n\n\t\t# Runs a loop until fewer than two operands or fewer than 1\n\t\t# operators are present in their respective containers.\n\t\tuntil @operands.size == 1 || @operators.size == 0 do\n\t\t\t# Pops the first operator from the front of the queue.\n\t\t\toperator = @operators.shift\n\n\t\t\t# Pops the top and second-to-top operands off of the stack.\n\t\t\topright = @operands.pop\n\t\t\topleft = @operands.pop\n\n\t\t\t# Returns prematurely before division by zero occurs.\n\t\t\tif operator == \"/\" && opright == 0\n\t\t\t\tputs \"division by zero\"\n\t\t\t\treturn [0, false]\n\t\t\tend\n\n\t\t\t# Sends the operator and the right operand to the left operand\n\t\t\t# and thereby invokes FixedNum#+, the method used for adding\n\t\t\t# integers.\n\t\t\t@operands.push(opleft.send(operator, opright))\n\t\tend\n\n\t\t# Returns the last element of @operands and the value of @valid.\n\t\t[@operands[-1], @valid]\n\tend",
"def evaluate\n stack = Stack.new\n\n tokens.each do |token|\n if numeric?(token)\n stack.push(token.to_i)\n elsif operator?(token)\n args = []\n SYMBOL_TABLE[token].arity.times do\n args.unshift(stack.pop)\n end\n\n stack.push(call_operator(token, *args))\n else\n raise \"omg what is this token?\"\n end\n end\n\n stack.pop\n end",
"def postfix_evaluator(equation)\n stack = []\n for i in equation do\n if str_to_num(i)\n stack.push(str_to_num(i))\n puts stack\n elsif (\"+-*/\").include?(i)\n second_num = stack.pop\n if stack != []\n first_num = stack.pop\n result = math(i, first_num, second_num)\n stack.push(result)\n else\n raise \"Not enough arguments\"\n end\n else\n raise \"Invalid number\"\n end\n end\n stack.pop()\nend",
"def convert_operator_to_text(op)\n case op\n when '1'\n 'add'\n when '2'\n 'subtract'\n when '3'\n 'multiply'\n when '4'\n 'divide'\n end\nend",
"def operation_of(a, b, op)\n if op == \"add\"\n return a + b\n elsif op == \"subtract\"\n return a - b \n elsif op == \"multiply\"\n return a * b \n elsif op == \"divide\"\n if b == 0\n return \"undefined\"\n else\n return a / b\n end\n end\nend",
"def build_operand(arg)\n if (arg.is_a?(AS::Parser::NumLiteralArgNode))\n if (arg.value.fits_u8?)\n # no shifting needed\n @operand = arg.value\n @i = 1\n elsif (op_with_rot = calculate_u8_with_rr(arg))\n @operand = op_with_rot\n @i = 1\n else\n raise AS::AssemblyError.new(AS::ERRSTR_NUMERIC_TOO_LARGE, arg)\n end\n elsif (arg.is_a?(AS::Parser::RegisterArgNode))\n @operand = reg_ref(arg)\n @i = 0\n elsif (arg.is_a?(AS::Parser::ShiftNode))\n rm_ref = reg_ref(arg.argument)\n @i = 0\n shift_op = {'lsl' => 0b000, 'lsr' => 0b010, 'asr' => 0b100,\n 'ror' => 0b110, 'rrx' => 0b110}[arg.type]\n if (arg.type == 'ror' and arg.value.nil?)\n # ror #0 == rrx\n raise AS::AssemblyError.new('cannot rotate by zero', arg)\n end\n \n arg1 = arg.value\n if (arg1.is_a?(AS::Parser::NumLiteralArgNode))\n if (arg1.value >= 32)\n raise AS::AssemblyError.new('cannot shift by more than 31', arg1)\n end\n shift_imm = arg1.value\n elsif (arg1.is_a?(AS::Parser::RegisterArgNode))\n shift_op |= 0x1;\n shift_imm = reg_ref(arg1) << 1\n elsif (arg.type == 'rrx')\n shift_imm = 0\n end\n \n @operand = rm_ref | (shift_op << 4) | (shift_imm << 4+3)\n else\n raise AS::AssemblyError.new(AS::ERRSTR_INVALID_ARG, arg)\n end\n end",
"def perform_operation(operator)\n operands = stack.last(2)\n if valid_operation?(operator, operands)\n operands = stack.pop(2).map(&:to_f)\n new_value = operands[0].send(operator, operands[1]).to_s\n\n Input.new(new_value)\n end\n end",
"def operation_to_message(op)\n case op\n when '1'\n '+'\n when '2'\n '-'\n when '3'\n '/'\n when '4'\n '*'\n end\nend",
"def calculator(x, operator, y)\r\n\r\n\tif ['+', '-', '*', '/'].include? operator\r\n\t\tcalculation = x.send(operator.to_sym, y) #send x to object (operator which has been converted to a symbol) and y. calculation will now = x (operator) y\r\n\telse\r\n\t\tputs \"ERROR! Invalid input. Please try again.\"\r\n\tend\r\n\treturn calculation #previously had this set to 'print' instead of 'return' which was causing issues when needing to print a history of values returned\r\nend",
"def process_op\n # validate_op\n (opcode, modes, addrs) = fetch_instruction\n\n\n case opcode\n\n # ADD: 1, *X, *Y, *(X+Y)\n when 1\n catch_fire if modes[2] == 1\n result = @at.lookup(addrs[0], modes[0]) + @at.lookup(addrs[1], modes[1])\n @at.write(addrs[2], modes[2], result)\n @counter += 4\n\n # MULT: 2, *X, *Y, *(X+Y)\n when 2\n catch_fire if modes[2] == 1\n result = @at.lookup(addrs[0], modes[0]) * @at.lookup(addrs[1], modes[1])\n @at.write(addrs[2], modes[2], result)\n @counter += 4\n\n # INPUT: 3, ADDR\n when 3\n catch_fire if modes[0] == 1\n result = read_input\n if result.nil?\n @waiting = true\n return 0\n end\n @at.write(addrs[0], modes[0], result)\n @counter += 2\n\n # OUTPUT: 4, *ADDR\n when 4\n value = @at.lookup(addrs[0], modes[0])\n write_output(value)\n @counter += 2\n\n # JUMP-IF-TRUE: 5, *BOOL, *INST_PTR\n when 5\n if @at.lookup(addrs[0], modes[0]) != 0\n @counter = @at.lookup(addrs[1], modes[1])\n else\n @counter += 3\n end\n\n # JUMP-IF-FALSE: 6, *BOOL, *INST_PTR\n when 6\n if @at.lookup(addrs[0], modes[0]) == 0\n @counter = @at.lookup(addrs[1], modes[1])\n else\n @counter += 3\n end\n\n # LESS-THAN: 7, *X, *Y, *(X<Y?1:0)\n when 7\n catch_fire if modes[2] == 1\n result = @at.lookup(addrs[0], modes[0]) < @at.lookup(addrs[1], modes[1]) ? 1 : 0\n @at.write(addrs[2], modes[2], result)\n @counter += 4\n\n # EQUALS: 8, *X, *Y, *(X=Y?1:0)\n when 8\n catch_fire if modes[2] == 1\n result = @at.lookup(addrs[0], modes[0]) == @at.lookup(addrs[1], modes[1]) ? 1 : 0\n @at.write(addrs[2], modes[2], result)\n @counter += 4\n\n # UPDATE OFFSET: 9 *OFFSET\n when 9\n @at.offset += @at.lookup(addrs[0], modes[0])\n @counter += 2\n\n # HALT: 99\n when 99\n halt\n @counter += 1\n\n else\n catch_fire(\"opcode: #{opcode}\")\n end\n end",
"def minilang(program)\n register = 0\n stack = []\n\n program.split.each do |step|\n p step\n case step\n when 'PUSH' then stack.push(register)\n when 'ADD' then register += stack.pop\n when 'SUB' then register -= stack.pop\n when 'MULT' then register *= stack.pop\n when 'DIV' then register /= stack.pop\n when 'MOD' then register %= stack.pop\n when 'POP' then register = stack.pop\n when 'PRINT' then puts register\n else register = step.to_i\n end\n p stack\n end\nend",
"def arithmetic(a, b, operator)\n $oper = operator\n case $oper\n when 'add'\n return a + b\n\n when 'subtract'\n return a - b\n\n when 'multiply'\n return a * b\n\n when 'divide'\n return a / b\n \n end\nend",
"def evaluate\n stack = Stack.new\n\n tokens.each do |token|\n if numeric?(token)\n stack.push(token.to_i)\n elsif operator?(token)\n args = []\n\n SYMBOL_TABLE[token].arity.times do\n # This adds the return value of stack.pop to the beginning of the\n # args array\n args.unshift(stack.pop)\n end\n\n # The *args syntax might be unfamiliar. It's called the \"splat\"\n # operator and among other things it lets you turn an array into\n # a list of arguments.\n stack.push(call_operator(token, *args))\n else\n raise \"omg what is this token even?\"\n end\n end\n\n stack.pop\n end",
"def evaluate\n case @op\n when 'println'\n v = @args[0]\n v = v.evaluate if v.is_a?(AST)\n puts v\n when '+'\n sum = 0\n @args.each do |x|\n x = x.evaluate if x.is_a?(AST)\n sum += x\n end\n return sum\n when '-'\n diff = @args[0]\n diff = diff.evaluate if diff.is_a?(AST)\n args_tail = @args.slice(1, args.length-1)\n args_tail.each do |x|\n x = x.evaluate if x.is_a?(AST)\n diff -= x\n end\n return diff\n when '*'\n prod = 1\n @args.each do |x|\n x = x.evaluate if x.is_a?(AST)\n prod *= x\n end\n return prod\n else\n raise \"Unrecognized op '#{@op}'\"\n end\n end",
"def calculate_str(st)\n first_num = ''\n operator = ''\n second_num = ''\n \n characters = st.chars\n \n characters.each do |char|\n if char.match?(/[0-9]/) or char.eql?('.')\n if operator == ''\n first_num << char\n else\n second_num << char\n end\n elsif char.match?(/(\\+|-|\\*|\\/)/)\n operator << char \n else\n next\n end\n end\n result = eval first_num + operator + second_num\n result.round.to_i.to_s\nend",
"def calculate_answer(operator, a, b)\r\n\r\n if operator == \"add\"\r\n return result= a + b\r\n elsif operator == \"subtract\"\r\n return result = a - b\r\n elsif operator == \"multiply\"\r\n return result = a * b\r\n elsif operator == \"divide\"\r\n return result = a / b\r\n\r\n end\r\n\r\nend",
"def calc(expr, verbose=false)\n # hash of str: func for operations\n ops_hash = {'+': method(:add), '-': method(:subt),\n '*': method(:mult), '/': method(:div),\n '**': method(:pow), '^': method(:pow)}\n\n # parse expr\n expr.strip!\n expr_arr = expr.split\n\n # check expression validity\n unless check_expr(expr_arr, false)\n return nil\n end\n\n j = 0 # used to track index while handling parens\n\n # find matching parens, then replace parens and contents with result of contents\n while j < (expr_arr.length - 1) do\n # check parens and get nest info. needs to be done inside this loop\n # if not, info fails to match as expression changes\n nest = check_parens(expr_arr)\n unless nest\n return nil\n end\n\n match_j = nil # Initialize match_j so later code can find it\n # find open paren\n if PAIRS.key?(expr_arr[j])\n # find matching close paren\n nest.each do |info_arr|\n if info_arr[2] == j\n match_j = info_arr[3]\n end\n end\n\n # join contents and send to calc\n temp_expr = expr_arr[j+1...match_j].join(' ')\n temp_result = calc(temp_expr, verbose)\n\n # return if internal expression was invalid\n unless temp_result\n return nil\n end\n\n # replace parens and contents with temp result\n expr_arr[j..match_j] = temp_result\n j = 0 # indices got moved and removed, so start from beginning\n else\n j += 1\n end\n end\n\n # If, after dealing with parens, there is only one element, return it\n if expr_arr.length == 1\n return expr_arr[0].to_f\n end\n\n result = 0 # initialize result variable so the return statement can find it\n\n # search for operations in order\n OPS.each do |op_set|\n i = 0\n\n # search expression for current operations\n # if found: calculate, replace, and search from begining of expression\n # else: move to next element in expression\n while i < (expr_arr.length - 1) do\n if op_set.include?(expr_arr[i])\n # find and assign operation and values\n op = expr_arr[i]\n x = expr_arr[i-1]\n y = expr_arr[i+1]\n\n # call appropriate op function\n result = ops_hash[op.to_sym].(x.to_f, y.to_f)\n\n # replace the 3 used elements with the result\n expr_arr[i-1..i+1] = result\n i = 0 # indices got moved and removed, so start from beginning\n\n # print verbose output\n if verbose and not expr_arr.length == 1\n puts expr_arr.join(\" \")\n end\n else\n i += 1\n end\n end\n end\n return result\nend",
"def cal_sol(str)\n par1=0\n par2=0\n array = str.split('')\n return str if array.none?(%r{[/*/+-/(/)]})\n while array.any?('(')\n i=1\n while i<array.length\n if array[i]=='(' || array[i]==')'\n par1=par2\n par2=i\n end\n if array[par1]=='(' && array[par2]==')'\n array = (par1!=0 ? array[0..par1-1] : []).concat([cal_sol(array[par1+1..par2-1].join(''))]).concat(array[par2+1..array.length])\n i=par1\n par2=par1-1\n par1=par1-1\n end\n i+=1\n end\n end\n new_string = array.join('')\n numbers= new_string.split(%r{[/*/+-]})\n signs= new_string.split(%r{[^/*/+-]}).join('').split('')\n elements = []\n (numbers.length+signs.length).times do |i|\n if i%2==0\n elements.push(numbers[0])\n numbers.delete_at(0)\n else \n elements.push(signs[0])\n signs.delete_at(0)\n end\n end\n operations = ['/','*','-','+']\n operations.each do |ops|\n i=1\n while i<elements.length-1\n if elements[i]==ops\n new_value= [elements[i-1].to_f, elements[i+1].to_f].inject(ops.to_sym)\n puts new_value\n elements = (i>=2 ? elements[0..i-2] : []).concat([new_value]).concat(elements[i+2..elements.length])\n i-=1\n end\n i+=1\n end\n end\n elements[0].to_s\nend",
"def bc(string)\n # initialize the operators and integers array\n operators = []\n integers = []\n\n # separate integers and operators into different arrays\n integers = string.split(/\\+|\\-|\\*|\\//).map(&:to_i)\n string.each_char do |c|\n if c.match /\\+|\\-|\\*|\\//\n operators << c\n end\n end\n\n # we want to handle * and / first\n count = 0\n operators.each_with_index do |o, i|\n if o.match /\\*|\\//\n r = integers[i-count].send(o, integers[i+1-count])\n integers.delete_at i+1-count\n integers.delete_at i-count\n integers.insert(i, r)\n count += 1\n end\n end\n\n # remove all * and / operators\n operators = operators.select do |o|\n !o.match /\\*|\\//\n end\n\n # we want to handle + and -\n integers.compact!\n count = 0\n operators.each_with_index do |o, i|\n if o.match /\\+|\\-/\n r = integers[i-count].send(o, integers[i+1-count])\n integers.delete_at i+1-count\n integers.delete_at i-count\n integers.insert(i, r)\n count += 1\n end\n end\n\n integers.compact\nend",
"def opcode(op,cond,args) \"#{op}#{cond} #{args.join ','}\" end",
"def operation_of(a, b, op)\n if op == \"add\"\n return a + b\n elsif op == \"subtract\"\n return a - b\n elsif op == \"multiply\"\n return a * b\n elsif op == \"divide\"\n if b == 0\n return \"undefined\"\n else\n return a / b\n end\n end\nend",
"def run(instruction)\n case instruction\n\n # add\n when /add (#{REG}) (#{INT})/\n @registers[$1] += $2.to_i\n when /add (#{REG}) (#{REG})/\n @registers[$1] += @registers[$2]\n\n # jgz\n when /jgz (#{REG}) (#{INT})/\n @ic += $2.to_i - 1 unless @registers[$1] <= 0\n when /jgz (#{INT}) (#{INT})/\n @ic += $2.to_i - 1 unless $1.to_i <= 0\n when /jgz (#{REG}) (#{REG})/\n @ic += @registers[$2] - 1 unless @registers[$1] <= 0\n\n # mod\n when /mod (#{REG}) (#{INT})/\n @registers[$1] %= $2.to_i\n when /mod (#{REG}) (#{REG})/\n @registers[$1] %= @registers[$2]\n\n # mul\n when /mul (#{REG}) (#{INT})/\n @registers[$1] *= $2.to_i\n when /mul (#{REG}) (#{REG})/\n @registers[$1] *= @registers[$2]\n\n # set\n when /set (#{REG}) (#{INT})/\n @registers[$1] = $2.to_i\n when /set (#{REG}) (#{REG})/\n @registers[$1] = @registers[$2]\n\n # snd\n when /snd (#{INT})/\n @parent.send(@target, $1.to_i)\n when /snd (#{REG})/\n @parent.send(@target, @registers[$1])\n\n # rcv\n when /rcv (#{REG})/\n @waiting = true\n @receiver = $1\n when /rcv (#{INT})/\n @waiting = true\n @receiver = $1\n end\n end",
"def calculate_answer(operator, a, b)\n if operator == \"add\"\n a + b \n elsif operator == \"subtract\"\n a - b\n elsif operator == \"multiply\"\n a * b\n elsif operator == \"divide\"\n a / b\n elsif operator == \"exponent\"\n a ** b\n elsif operator == \"modulus\"\n a % b\n end\nend",
"def calculate(s)\n stack = []\n num = 0\n res = 0 # For the on-going result\n sign = 1 # 1 means positive, -1 means negative\n\n s.each_char do |char|\n if char =~ /\\d/\n num = num * 10 + char.to_i\n elsif [\"+\", \"-\"].include?(char)\n res += sign * num\n num = 0\n sign = char == \"+\" ? 1 : -1\n elsif char == \"(\"\n stack << res\n stack << sign\n sign = 1\n res = 0\n elsif char == \")\"\n res += num * sign\n res *= stack.pop\n res += stack.pop\n num = 0\n end\n end\n\n res + num * sign\nend",
"def commands\n @commands = {\n 1 => {:word => :add, :inc => 4},\n 2 => {:word => :mult, :inc => 4},\n 3 => {:word => :in, :inc => 2},\n 4 => {:word => :out, :inc => 2},\n 5 => {:word => :jnz, :inc => 0},\n 6 => {:word => :jz, :inc => 0},\n 7 => {:word => :lt, :inc => 4},\n 8 => {:word => :eq, :inc => 4},\n 99 => {:word => :halt},\n }\nend",
"def evaluatePostfix(exprStr)\n \n # split the string into an array by spaces\n exprStr = exprStr.split(\" \");\n\n # stack the holds \n stack = Array.new\n\n # loop through each element in the array\n exprStr.each do |ele|\n \n # check if the current value is an integer\n if operand? ele\n\n # convert the element to an integer and push onto stack\n stack.push ele.to_i\n\n # check if current element is an operator\n elsif operator? ele\n\n # update the ^ operator\n if ele.eql? '^'\n ele = \"**\"\n end \n \n # pop the last two elements from the array\n y, x = stack.pop, stack.pop\n \n # calculate the result of the operation\n result = applyOperator(x, y, ele)\n\n # push the result onto the stack\n stack.push(result)\n end\n end\n return stack.pop\n end",
"def run_instruction(vm, command)\n\n # declare a symbol and save it in the next available memory\n # position. The value will be stored in the position after that\n if command[0] == 'DEC'\n vm.memory[vm.memory_counter] = command[1]\n vm.memory_counter += 2\n\n elsif command[0] == 'LDA'\n index = vm.memory.index(command[1])\n vm.register_a = @converter.to_decimal(vm.memory[index + 1])\n\n elsif command[0] == 'LDB'\n index = vm.memory.index(command[1])\n vm.register_b = @converter.to_decimal(vm.memory[index + 1])\n\n # Loads the integer value into the accumulator register. The value could be negative.\n elsif command[0] == 'LDI'\n vm.register_a = command[1].to_i\n\n # store register a value at symbol (command[1])\n # if no such symbol exists, make one\n elsif command[0] == 'STR'\n index = vm.memory.index(command[1])\n vm.memory[index + 1] = @converter.to_binary(vm.register_a)\n\n # Exchanges the content registers A and B.\n elsif command[0] == 'XCH'\n temp = vm.register_a\n vm.register_a = vm.register_b\n vm.register_b = temp\n\n # Transfers control to instruction at address number in program memory\n elsif command[0] == 'JMP'\n vm.pc = command[1].to_i - 1\n\n # Transfers control to instruction at address number if the zero-result bit is set.\n elsif command[0] == 'JZS'\n vm.pc = command[1].to_i - 1 if vm.zero_bit == 1\n\n # Transfers control to instruction at address number if the overflow bit is set.\n elsif command[0] == 'JVS'\n vm.pc = command[1].to_i - 1 if vm.overflow == 1\n\n # Adds the content of registers A and B. The sum is stored\n # in A. The overflow and zero-result bits are set or cleared as needed.\n elsif command[0] == 'ADD'\n result = vm.register_a.to_i + vm.register_b.to_i\n if result > 2_147_483_647 || result < -2_147_483_648\n vm.overflow = 1\n dif = result - 2_147_483_647\n vm.register_a = dif - 2_147_483_648\n else\n vm.register_a = result\n vm.overflow = 0\n end\n vm.zero_bit = if vm.register_a.zero?\n 1\n else\n 0\n end\n elsif command[0] == 'HLT'\n vm.done = true\n end\n vm.pc += 1\n end",
"def Calculator(leftParam, rightParam, operator)\n\n case operator\n\n when \"+\"\n return leftParam + rightParam;\n when \"*\"\n\n i = 0\n result = 0\n while i < leftParam #2\n result = result + rightParam #@\n i= i + 1\n end\n\n return result\n end\nend",
"def operation_to_message(op)\n case op\n when '1'\n \"Adding\"\n when '2'\n \"Subtracting\"\n when '3'\n \"Multiplying\"\n when '4'\n \"Dividing\"\n end\nend",
"def operation_to_message(op)\n case op\n when '1'\n \"adding\"\n when '2'\n 'subtracting'\n when '3'\n 'multiplying'\n when '4'\n 'dividing'\n end\n end",
"def operation_to_message(op)\n case op\n when \"1\"\n \"Adding\"\n when \"2\"\n \"Subtracting\"\n when \"3\"\n \"Multiplying\"\n when \"4\"\n \"Dividing\"\n end\nend",
"def evaluate\n stack = Stack.new\n\n tokens.each do |token|\n if numeric?(token)\n stack.push(token.to_i)\n elsif token == \"+\"\n # handle addition\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(lhs + rhs)\n elsif token == \"*\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(lhs * rhs)\n elsif token == \"-\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(lhs - rhs)\n elsif token == \"/\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(lhs / rhs)\n elsif token == \"^\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(lhs ** rhs)\n elsif token == \"%\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(lhs % rhs)\n elsif token == \"max\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push([lhs, rhs].max)\n elsif token == \"min\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push([lhs, rhs].min)\n elsif token == \"rand\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push(rand(lhs..rhs))\n elsif token == \"sample\"\n rhs = stack.pop # right-hand side\n lhs = stack.pop # left-hand side\n stack.push([lhs, rhs].sample)\n elsif token == \"!\"\n num = stack.pop\n stack.push(factorial(num))\n else\n raise \"omg what is this token even?\"\n end\n end\n\n stack.pop\n end",
"def operation_to_message(op)\n case op\n when '1'\n 'Adding'\n when '2'\n 'Subtracting'\n when '3'\n 'Multiplying'\n when '4'\n 'Dividing'\n end\nend",
"def operation_to_message(op)\n case op\n when '1'\n 'Adding'\n when '2'\n 'Subtracting'\n when '3'\n 'Multiplying'\n when '4'\n 'Dividing'\n end\nend",
"def eval_string\n # Toggle for extra computation level; i.e. variables (see f/b/r/l functions above)\n meta = false\n # Local holder for executable code strings\n eval_string_holder = []\n # Local holder for final JSON output code\n output = []\n # Check for invalid command sequence from above\n if @parsed_command_string\n # Go through the @parsed_command_string instance variable created above\n @parsed_command_string.each do | subcommand |\n # Checks to see if the commands are intended for the robot\n if subcommand[ 1 ].match( /((f|b|l|r) (10|20|30|40|50|60|70|80|90))/ )\n # Adds internal code to enable robot instructions to be inserted and appropriately formatted into the local output\n # holder array\n subcommand[ 1 ] = \"output.push( '#{ subcommand[ 1 ] }' )\"\n # Check for variable assignment, make sure it's not catching \"if\"\n elsif subcommand[ 1 ].match( /((f|b|l|r) x)/ ) && !subcommand[ 1 ].match( /if/ )\n # Toggle variable for extra computational level\n meta = true\n end\n # Adds code strings to be executed to local holder array\n eval_string_holder << subcommand[ 1 ]\n end\n # Combines the disparate bits of code with \";\" line separation character\n executable = eval_string_holder.join( \"; \" )\n # puts eval(eval( executable ))\n # Rescue loop\n begin\n # Execute code string; with extra layer if necessary\n meta ? eval( eval( executable ) ) : eval( executable ) \n # If there's an error...\n rescue Exception => exc\n # Beep\n print \"\\a\"\n # Execute the @rescue string instead ( defined in initilazation )\n eval( @rescue )\n end\n else\n # Beep\n print \"\\a\"\n # Rescue sequence\n eval( @rescue )\n end\n # Assign the contents of the output holder array ( formatted robot commands )to new @command_array \n # instance variable for access below\n @command_array = output\n end",
"def parse_instruction(integer)\n # TODO: Instruction classes? INP as \"less special case\", and JIT/JIF?\n opcode = integer % 100\n if [INP].include? opcode\n [opcode, (integer % 1000) / 100]\n else\n [opcode,\n (integer % 1000) / 100,\n (integer % 10_000) / 1000,\n (integer % 100_000) / 10_000]\n end\n end",
"def evaluate_postfix(str)\n calc = Stack.new\n i = 0\n while i < str.length\n case str[i]\n when \"+\"\n calc.push (calc.pop + calc.pop)\n when \"-\"\n value1 = calc.pop\n value2 = calc.pop\n calc.push (value2 - value1)\n when \"*\"\n calc.push (calc.pop * calc.pop)\n when \"/\"\n value1 = calc.pop\n value2 = calc.pop\n calc.push (value2 / value1)\n else\n calc.push str[i].to_i\n end\n i += 1\n end\n return calc.pop\nend",
"def operators= new_ops\n @operators = new_ops.gsub(/[^+*-]/, '').split(//)\n reset\n end",
"def output_op(code, op, indent=2)\n case op\n when Dot\n code << indentify(\"_tmp = match_dot\\n\", indent)\n when LiteralString\n code << indentify(\"_tmp = match_string(#{op.string.dump})\\n\", indent)\n when LiteralRegexp\n if op.regexp.respond_to?(:kcode)\n lang = op.regexp.kcode.to_s[0,1]\n else\n # Let default ruby string handling figure it out\n lang = \"\"\n end\n code << indentify(\"_tmp = scan(/\\\\G#{op.regexp}/#{lang})\\n\", indent)\n when CharRange\n if op.start.bytesize == 1 and op.fin.bytesize == 1\n if op.start.respond_to? :getbyte\n left = op.start.getbyte 0\n right = op.fin.getbyte 0\n else\n left = op.start[0]\n right = op.fin[0]\n end\n\n code << indentify(\"_tmp = match_char_range(#{left}..#{right})\\n\", indent)\n else\n raise \"Unsupported char range - #{op.inspect}\"\n end\n when Choice\n code << \"\\n\"\n code << indentify(\"begin # choice\\n\", indent)\n op.ops.each_with_index do |n,idx|\n if idx > 0\n code << indentify(\" break if _tmp\\n\", indent)\n end\n output_op code, n, (indent+1)\n end\n code << indentify(\"end while false # end choice\\n\\n\", indent)\n when Multiple\n if op.min == 0 and op.max == 1\n code << indentify(\"# optional\\n\", indent)\n output_op code, op.op, indent\n if op.save_values\n code << indentify(\"@result = nil unless _tmp\\n\", indent)\n end\n code << indentify(\"_tmp = true # end optional\\n\", indent)\n elsif op.min == 0 and !op.max\n if op.save_values\n ary = save(\"_ary\")\n code << indentify(\"#{ary} = [] # kleene\\n\", indent)\n code << indentify(\"while true\\n\", indent)\n else\n code << indentify(\"while true # kleene\\n\", indent)\n end\n\n output_op code, op.op, (indent+1)\n code << indentify(\" break unless _tmp\\n\", indent)\n if op.save_values\n code << indentify(\" #{ary} << @result\\n\", indent)\n end\n code << indentify(\"end\\n\", indent)\n if op.save_values\n code << indentify(\"@result = #{ary}\\n\", indent)\n end\n code << indentify(\"_tmp = true # end kleene\\n\", indent)\n\n else\n ss = save()\n code << indentify(\"#{ss} = self.pos # repetition\\n\", indent)\n if op.save_values\n ary = save(\"_ary\")\n incr = \"#{ary} << @result\"\n cnt = \"#{ary}.size\"\n code << indentify(\"#{ary} = []\\n\", indent)\n else\n cnt = save(\"_count\")\n incr = \"#{cnt} += 1\"\n code << indentify(\"#{cnt} = 0\\n\", indent)\n end\n code << indentify(\"while true\\n\", indent)\n output_op code, op.op, (indent+1)\n code << indentify(\" break unless _tmp\\n\", indent)\n code << indentify(\" #{incr}\\n\", indent)\n if op.max\n code << indentify(\" break if #{cnt} == #{op.max}\\n\", indent)\n end\n code << indentify(\"end\\n\", indent)\n if op.save_values\n code << indentify(\"@result = #{ary}\\n\", indent)\n end\n code << indentify(\"_tmp = #{cnt} >= #{op.min}\\n\", indent)\n code << indentify(\"unless _tmp\\n\", indent)\n code << indentify(\" self.pos = #{ss}\\n\", indent)\n if op.save_values\n code << indentify(\" @result = nil\\n\", indent)\n end\n code << indentify(\"end # end repetition\\n\", indent)\n end\n\n when Sequence\n ss = save()\n code << \"\\n\"\n code << indentify(\"#{ss} = self.pos\\n\", indent)\n code << indentify(\"begin # sequence\\n\", indent)\n op.ops.each_with_index do |n, idx|\n if idx > 0\n code << indentify(\" break unless _tmp\\n\", indent)\n end\n output_op code, n, (indent+1)\n end\n code << indentify(\"end while false\\n\", indent)\n code << indentify(\"unless _tmp\\n\", indent)\n code << indentify(\" self.pos = #{ss}\\n\", indent)\n code << indentify(\"end # end sequence\\n\\n\", indent)\n when AndPredicate\n ss = save()\n code << indentify(\"#{ss} = self.pos\\n\", indent)\n if op.op.kind_of? Action\n code << indentify(\"_tmp = begin; #{op.op.action.strip}; end\\n\", indent)\n else\n output_op code, op.op, indent\n end\n code << indentify(\"self.pos = #{ss}\\n\", indent)\n when NotPredicate\n ss = save()\n code << indentify(\"#{ss} = self.pos\\n\", indent)\n if op.op.kind_of? Action\n code << indentify(\"_tmp = begin; #{op.op.action.strip}; end\\n\", indent)\n else\n output_op code, op.op, indent\n end\n code << indentify(\"_tmp = !_tmp\\n\", indent)\n code << indentify(\"self.pos = #{ss}\\n\", indent)\n when RuleReference\n if op.arguments\n code << indentify(\"_tmp = apply_with_args(:#{method_name op.rule_name}, #{op.arguments[1..-2]})\\n\", indent)\n else\n code << indentify(\"_tmp = apply(:#{method_name op.rule_name})\\n\", indent)\n end\n when InvokeRule\n if op.arguments\n code << indentify(\"_tmp = #{method_name op.rule_name}#{op.arguments}\\n\", indent)\n else\n code << indentify(\"_tmp = #{method_name op.rule_name}()\\n\", indent)\n end\n when ForeignInvokeRule\n if op.arguments\n code << indentify(\"_tmp = @_grammar_#{op.grammar_name}.external_invoke(self, :#{method_name op.rule_name}, #{op.arguments[1..-2]})\\n\", indent)\n else\n code << indentify(\"_tmp = @_grammar_#{op.grammar_name}.external_invoke(self, :#{method_name op.rule_name})\\n\", indent)\n end\n when Tag\n output_op code, op.op, indent\n if op.tag_name and !op.tag_name.empty?\n code << indentify(\"#{op.tag_name} = @result\\n\", indent)\n end\n when Action\n code << indentify(\"@result = begin; \", indent)\n code << op.action.strip << \"; end\\n\"\n if @debug\n code << indentify(\"puts \\\" => \\\" #{op.action.dump} \\\" => \\#{@result.inspect} \\\\n\\\"\\n\", indent)\n end\n code << indentify(\"_tmp = true\\n\", indent)\n when Collect\n code << indentify(\"_text_start = self.pos\\n\", indent)\n output_op code, op.op, indent\n code << indentify(\"if _tmp\\n\", indent)\n code << indentify(\" text = get_text(_text_start)\\n\", indent)\n code << indentify(\"end\\n\", indent)\n when Bounds\n code << indentify(\"_bounds_start = self.pos\\n\", indent)\n output_op code, op.op, indent\n code << indentify(\"if _tmp\\n\", indent)\n code << indentify(\" bounds = [_bounds_start, self.pos]\\n\", indent)\n code << indentify(\"end\\n\", indent)\n else\n raise \"Unknown op - #{op.class}\"\n end\n end",
"def operation_to_message(string)\n answer = case string\n when '1'\n 'ADDING'\n when '2'\n 'SUBTRACTING'\n when '3'\n 'MULTIPLYING'\n when '4'\n 'DIVIDING'\n end\n answer\nend",
"def execute_expression\n valid_input\n to_roman(to_num(@operand_one).send(@operator, to_num(@operand_two)))\n end",
"def op; end",
"def operation_to_message(op)\n word = case op\n when '1'\n 'Adding'\n when '2'\n 'Subtracting'\n when '3'\n 'Multiplying'\n when '4'\n 'Dividing'\n end\n word\nend",
"def evaluate(ex)\n @stack=[]\n @expr.each do |el|\n case el\n when HopExprVar\n # evaluate variable\n var,dot,field=el.value.partition('.')\n if field==''\n # scalar\n val=VarStor.getScalar(ex,el.value)\n else\n # cortege field\n begin\n val=VarStor.getCortege(ex,var)[field]\n rescue\n warn \">> Opppps: #{var}.#{field}\"\n nil\n end\n end\n @stack.push val\n\n when Numeric, String\n # constant\n @stack.push el\n\n when HopExprOp\n case el.value\n when '+'\n a1=@stack.pop\n a2=@stack.pop\n warn \">>PLUS: #{a1},#{a2}\"\n raise SyntaxErrHopError if a2.nil?\n @stack.push a1.to_f+a2.to_f\n when '*'\n a1=@stack.pop\n a2=@stack.pop\n raise SyntaxErrHopError if a2.nil?\n @stack.push a1.to_f*a2.to_f\n when '-'\n a1=@stack.pop\n a2=@stack.pop\n warn \">>MINUS: #{a1},#{a2}\"\n raise SyntaxErrHopError if a2.nil?\n @stack.push a2.to_f-a1.to_f\n when '/'\n a1=@stack.pop\n a2=@stack.pop\n raise SyntaxErrHopError if a2.nil?\n @stack.push a2.to_f/a1.to_f\n when '%'\n a1=@stack.pop\n a2=@stack.pop\n raise SyntaxErrHopError if a2.nil?\n @stack.push a2.to_f%a1.to_f\n else\n raise SyntaxErrHopError\n end\n end #~case\n end # ~each expression\n raise SyntaxErrHopError.new(@expr.to_s+' ('+@stack.to_s+')') if @stack.size>1\n\n return @stack.pop\n end",
"def operation(operator, num1, num2)\n case operator \n when 1 \n puts \"The operational result is: #{num1.to_f + num2.to_f}\"\n puts \"==> #{num1.to_s} + #{num2.to_s} = #{num1.to_f + num2.to_f}\"\n when 2 \n puts \"The operational result is: #{num1.to_f - num2.to_f}\"\n puts \"==> #{num1.to_s} - #{num2.to_s} = #{num1.to_f - num2.to_f}\"\n when 3\n puts \"The operational result is: #{num1.to_f * num2.to_f}\"\n puts \"==> #{num1.to_s} * #{num2.to_s} = #{num1.to_f * num2.to_f}\"\n else\n puts \"The operational result is: #{num1.to_f / num2.to_f}\"\n puts \"==> #{num1.to_s} / #{num2.to_s} = #{num1.to_f / num2.to_f}\"\n end\nend",
"def eval\n return @value unless @value.nil?\n \n debug \"\\nfor RPN expression: #{expression}\\nTerm\\tAction\\tStack\"\n stack = []\n expression.split.each do |term|\n if Operators.has_key?(term)\n a, b = stack.pop(2)\n raise ArgumentError, \"not enough operands on the stack\" if b.nil?\n a = a.to_f if term == \"/\"\n op = (term == \"^\" ? \"**\" : term)\n stack.push(a.method(op).call(b))\n debug \"#{term}\\t#{Operators[term].english}\\t#{stack}\"\n else\n begin\n number = Integer(term) rescue Float(term)\n rescue ArgumentError\n raise ArgumentError, \"cannot handle term: #{term}\"\n end\n stack.push(number)\n debug \"#{number}\\tPUSH\\t#{stack}\"\n end\n end\n @value = stack.pop\n debug \"Value = #@value\"\n @value\n end"
] |
[
"0.7446514",
"0.73305297",
"0.7299608",
"0.726271",
"0.6940428",
"0.6920647",
"0.6903639",
"0.68655574",
"0.6813391",
"0.678495",
"0.67690766",
"0.67650366",
"0.6762735",
"0.6728278",
"0.67157835",
"0.6658182",
"0.6614905",
"0.6611889",
"0.66066694",
"0.6606039",
"0.6602687",
"0.659239",
"0.656202",
"0.6551191",
"0.6533552",
"0.64545506",
"0.6404576",
"0.6401491",
"0.6396229",
"0.63926643",
"0.63696414",
"0.6342193",
"0.63413996",
"0.6305266",
"0.62972426",
"0.6277693",
"0.62752163",
"0.6237562",
"0.62050104",
"0.6180226",
"0.61646944",
"0.615743",
"0.61509514",
"0.6140825",
"0.6139863",
"0.6139863",
"0.6139863",
"0.6139863",
"0.61202854",
"0.6082777",
"0.6080952",
"0.6077259",
"0.6043523",
"0.604234",
"0.60417056",
"0.6037763",
"0.60332835",
"0.6033156",
"0.60314924",
"0.60167885",
"0.6008602",
"0.6004721",
"0.60020673",
"0.6000469",
"0.59909093",
"0.5981863",
"0.59736884",
"0.59560204",
"0.5944775",
"0.59429944",
"0.59365153",
"0.5935862",
"0.5930582",
"0.59296024",
"0.5928914",
"0.5927432",
"0.5918622",
"0.5916983",
"0.5912438",
"0.590407",
"0.5901406",
"0.5898101",
"0.5896396",
"0.58919257",
"0.58895373",
"0.5888458",
"0.58875823",
"0.58875823",
"0.58788013",
"0.5875722",
"0.5869853",
"0.5860087",
"0.58561105",
"0.58520734",
"0.5850091",
"0.58478713",
"0.5847072",
"0.5844008",
"0.58424926",
"0.5841882"
] |
0.7063701
|
4
|
reset the raw parameters for each filter received by the form
|
def reset_filter_params
params[:search] = nil
params[:status] = nil
params[:unassigned] = nil
params[:assigned_to_me] = nil
params[:needs_attention] = nil
params[:year] = nil
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def reset_params\n @params = {}\n end",
"def reset\n @params = {}\n @query_filters = []\n @uri = ''\n self\n end",
"def reset\n super\n @params.values.uniq.each do |param|\n param.send(:reset) if param.is_a? Parameter\n end\n end",
"def reset\n all_filters.each(&:reset)\n validate\n end",
"def reset_filters\n @_filters = []\n end",
"def clear_all_filters_and_orders\n [:flag_id, :sort_by, :filter_by, :reset, :mask].each do |elem|\n params[elem] = nil\n # session[elem] = nil # though, this is not required\n end\n end",
"def ResetFilters\n @filters = []\n @anchor = []\n end",
"def reset\n super\n @params.values.uniq.each { |param| param.reset if param.is_a? Parameter }\n end",
"def reset\n @params = initial_params\n self\n end",
"def reset\n @params = Hash.new\n end",
"def reset_all\n @params.each_key {|k| reset(k.to_s)}\n @params = {}\n end",
"def prepare_filters\n params = instance_values.symbolize_keys\n filters = clean_params(params)\n validate_filters(filters)\n end",
"def filter_parameters=(_arg0); end",
"def filter_parameters=(_arg0); end",
"def filter_parameters; end",
"def filter_parameters; end",
"def populate_filters(_inputs)\n super.tap do\n self.class.filters.each do |name, filter|\n next if given?(name)\n\n model_field = self.class.model_field_cache_inverse[name]\n next if model_field.nil?\n\n value = public_send(model_field)&.public_send(name)\n public_send(\"#{name}=\", filter.clean(value, self))\n end\n end\n end",
"def filter_params\n @filter_params_cache ||= clean_hash(params[:filter]).with_indifferent_access\n end",
"def filtered_parameters; end",
"def prepare_params\n\n filtered_params = song_params\n\n # if no value specified, store a null\n filtered_params[:OrigBand] = nil if filtered_params[:OrigBand].strip.empty?\n filtered_params[:Author] = nil if filtered_params[:Author].strip.empty?\n filtered_params[:Lyrics] = nil if filtered_params[:Lyrics].strip.empty?\n filtered_params[:lyrics_ref] = nil if filtered_params[:lyrics_ref].strip.empty?\n filtered_params[:Comments] = nil if filtered_params[:Comments].strip.empty?\n\n filtered_params\n\n end",
"def filter_params\n @_filter_params ||=\n case params[:filter]\n when Hash, ActionController::Parameters\n default_filters.each_with_object({}) do |field, hash|\n unformatted_field = @request.unformat_key(field)\n hash[unformatted_field] = params[:filter][field]\n end\n end\n end",
"def set_all_parameters\n @screens.screen_set_filter_parameters.visible?\n @filter_data.parameters.each do |parameter|\n #ieraksta datus laukos\n @screens.screen_set_filter_parameters.set_parameter(parameter)\n end\n end",
"def clean_filters\n cleaned_filters = {}\n self.filters.each do |name, value|\n if (self.filter_options[name.to_sym][:fields].detect{|f| f[:value] == value } rescue false)\n cleaned_filters[name.to_sym] = value\n end\n end\n self.filters = cleaned_filters\n end",
"def remove_filters!\n @filters = []\n end",
"def clear_parameters\n @interface.clear_parameters\n current_parameters\n end",
"def params_reset\n buff = []\n names = []\n get_params(true).each do |param|\n if param[:type] == 'bool'\n if param[:value].is_a?(TrueClass)\n buff << 'true'\n elsif param[:value].is_a?(FalseClass)\n buff << 'false'\n else\n Utils_errors::critical_error(\"The param #{param[:string].gsub('_', ' ')} has a value of '#{param[:value]}' \\\n(#{param[:value].class.to_s}), it should be 'true' or 'false' (boolean)\")\n end\n else\n buff << param[:value]\n end\n names << param[:string] + ' = ?'\n end\n Utils_database::db_exec(\"UPDATE #{@db_name} SET #{names.join(', ')} WHERE id=1\", \"could not update #{@db_name}\", @db, buff)\n end",
"def resetFilter\n @current = @groups\n @pattern = nil\n end",
"def filter_params\n params[:f] || {}\n end",
"def filter_fields\n\t \n\t \tremove_attribute(:version)\n\t \tremove_attribute(:op_success)\n\t \tattributes\n\n\t \t\n\t end",
"def filter_fields\n\t \n\t \tremove_attribute(:version)\n\t \tremove_attribute(:op_success)\n\t \tattributes\n\n\t \t\n\t end",
"def filter_params\n if not @params_filtered\n # these values are automatically persisted\n # via the session\n @current_map = select_param :map, :symbol => true\n @current_language = select_param :lang\n @current_scope = select_param :scope\n @current_id = select_param :id\n # update the view state with values that must be communicated down-stream\n properties = PropertySet.new()\n properties[:language] = @current_language\n properties[:scope] = @current_scope\n properties[:map] = @current_map\n properties[:home] = Globals::DEFAULT[:id]\n @view_state[:properties] = properties\n @view_state[:languages] = Globals::LANGUAGES\n @view_state[:scopes] = Globals::SCOPES\n @view_state[:maps] = Globals::MAPS\n @view_state[:notice] = PropertySet.new()\n @view_state[:error] = PropertySet.new()\n @view_state[:success] = PropertySet.new()\n @params_filtered = true\n end\n end",
"def reset_search_params\n Parameters.sanitize(to_h).except(:page, :counter)\n end",
"def parameters_to_filter\n @parameters_to_filter ||= []\n end",
"def filter_method_params\n params.fetch(:filter_method, {})\n end",
"def filters=(_arg0); end",
"def filters=(_arg0); end",
"def reset\n @params = nil\n @logger = nil\n end",
"def clear_filters\n\t\t@filters = []\n\t\treturn self\n\tend",
"def filtering_params\n params.slice(:country, :data_source, :vaccine,\n :date_updated_start_date, :date_updated_end_date,\n :first_vaccine_date_start, :first_vaccine_date_end)\n end",
"def reset_property_filters\n current_user.company.properties.each do |p|\n session[p.filter_name] = nil\n end\n end",
"def filtering_params(params)\n \tparams.slice(:make, :color, :drive, :has_keys, :year, :state, :lot_number, :buy_now_price, :auction)\n\tend",
"def clear_filter\n @filter_string = ''\n @found_count = -1\n model.refilter\n filter\n end",
"def reset\n @authorizations = []\n @filters = []\n end",
"def reset! # :nodoc:\n @params = nil\n @request = nil\n @headers = nil\n end",
"def preprocess_data\n # Remove things if needed\n if @filter_keys\n @input = @input.delete_if{|k, v| !@filter_keys.include?(k)}\n end\n end",
"def clean_params(params)\n params.slice()\n end",
"def unsolved_params\n \n end",
"def reset\n\t\tself.log.debug \"Resetting validation state.\"\n\t\t@validated = false\n\t\t@valid = {}\n\t\t@parsed_params = nil\n\t\t@missing = []\n\t\t@unknown = []\n\t\t@invalid = {}\n\tend",
"def filters\n\t\t@filters_array = Array(@profile[:filters]) unless(@filters_array)\n\t\t@filters_array.each do |filter|\n\n\t\t\tif respond_to?( \"filter_#{filter}\" )\n\t\t\t\t@form.keys.each do |field|\n\t\t\t\t\t# If a key has multiple elements, apply filter to each element\n\t\t\t\t\t@field_array = Array( @form[field] )\n\n\t\t\t\t\tif @field_array.length > 1\n\t\t\t\t\t\t@field_array.each_index do |i|\n\t\t\t\t\t\t\telem = @field_array[i]\n\t\t\t\t\t\t\t@field_array[i] = self.send(\"filter_#{filter}\", elem)\n\t\t\t\t\t\tend\n\t\t\t\t\telse\n\t\t\t\t\t\tif not @form[field].to_s.empty?\n\t\t\t\t\t\t\t@form[field] = self.send(\"filter_#{filter}\", @form[field].to_s)\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@form\n\tend",
"def set_filters\n filter_param_keys = [\n 'brand', 'color',\n 'size', 'department', 'keywords'\n ]\n @filters = []\n filter_param_keys.each do |key|\n if !params[key].blank?\n params[key].split(',').each do |val|\n @filters << {:key => key, :val => val}\n end\n end\n end\n \n \n if params[:price]\n params[:price].split(',').each_slice(2).to_a.each do |range|\n @filters << {:key => 'price', :val => range.join(',')}\n end\n end\n\n if @products\n @brands = @products.facet('brand_facet').rows.sort_by{ |brand| brand.value.capitalize}\n @departments = @products.facet('department_facet').rows\n end\n \n @colors = ['green', 'blue', 'purple', 'red', 'pink', 'beige', 'brown', 'yellow', 'orange', 'black', 'white', 'gray', 'teal', 'glowing', 'gold', 'silver']\n \n if !@taxon.nil? && @taxon.has_size?\n sizes = (Spree::Product.sizes.sort_by{|size| size.position}.map(&:presentation) & @products.facet(\"size_facet\").rows.map(&:value))\n end\n end",
"def set_attributes(attrs)\n if attrs.has_key?(\"filters\")\n attrs = attrs.merge(attrs[\"filters\"])\n end\n super(attrs)\n end",
"def clear_instance_filters\n instance_filters.clear\n end",
"def initialize\n @all_filters = []\n @errors = []\n @conditions = nil\n filters\n reset\n end",
"def reset_search_params source_params\n sanitize_search_params(source_params).except(:page, :counter).with_indifferent_access\n end",
"def empty_out_future_params\n @future_params = {}\n end",
"def clear_properties\n @filter_hash.delete(:cifilterproperties)\n end",
"def reset_request\n @params = @headers = @body = nil\n end",
"def anonymous_filter_params\n p = params.required('payload')\n # p.permit!('controls_params')\n # p.permit!('columns_params')\n # p.permit!('sorting')\n # p.permit!('global_config')\n p.permit(\n 'name',\n 'controls_list' => [],\n 'controls_hl_mode' => [],\n 'controls_params' => {},\n 'columns_list' => [],\n 'columns_params' => {},\n 'sorting' => {},\n 'global_config' => {}\n ).merge(permit_hashes(p, [\n 'controls_params',\n 'columns_params',\n 'sorting',\n 'global_config'\n ]))\n end",
"def parse_params(params)\n all_filters.each {|f| f.reset; f.active = false}\n data = params.symbolize_keys\n Array(data[:fields]).each do |name|\n filter = all_filters.find {|f| f.name == name}\n if filter\n filter.active = true\n operator = data[:operators][name].to_sym\n filter.operator = operator if filter.operators.include?(operator)\n filter.value = data[:values][name] unless operator == :blank\n end\n end\n validate\n end",
"def parse_filters(params)\n if params['filters'].blank?\n Utilities::Geo::REGEXP_COORD.keys\n else\n params.permit(filters: [])[:filters].map(&:to_sym)\n end\n end",
"def Filter=(arg0)",
"def filter_params\n params.require(:filter).permit(:name, :brand, :description, :notes)\n end",
"def cleanup_parameters\n original_count = params.keys.size\n\n # Eliminate \"noise\" parameters.\n params.delete_if { |k, v| k.blank? || v.blank? }\n %w[utf8 commit].each { |k| params.delete(k) }\n\n # If parameters were removed, redirect to the corrected URL.\n will_redirect unless params.keys.size == original_count\n end",
"def filtering_params(params)\n params.slice(:shortlist, :client, :category, :updated_at, :costmodel, :state, :prio)\n end",
"def init_parameters\n @filters = []\n @sorts = {}\n @columns = {}\n @extra_fields = []\n @exporting = {}\n @operations = []\n @macro = Macro.new\n end",
"def set_filters\n @filters = ''\n @filters.concat(\"status:'Available'\")\n unless @manufacturer_or_publisher.blank?\n @filters.concat(\" AND (manufacturer:'#{@manufacturer_or_publisher}'\")\n @filters.concat(\" OR publisher:'#{@manufacturer_or_publisher}')\")\n end\n @filters.concat(\" AND category:'#{@category}'\") unless @category.blank?\n @filters.concat(\" AND seller_name:'#{@seller_name}'\") unless @seller_name.blank?\n end",
"def original_params\n @original_params || params\n end",
"def set_filters\n @filters ||= begin\n filters = []\n filters << { attribute: Gemgento::ProductAttribute.find_by!(code: 'color'), value: params[:color] } unless params[:color].blank?\n filters\n end\n end",
"def set_filter(opts)\n opts = check_params(opts,[:filters])\n super(opts)\n end",
"def filtered_parameters\n @filtered_parameters ||= parameter_filter.filter(parameters)\n end",
"def reset_filter!\n skip_before_action(:filter_access_filter) if method_defined?(:filter_access_filter)\n before_action :filter_access_filter\n end",
"def adjust_for_parameters(params)\n params = params[\"filter\"] if params[\"filter\"]\n \n #self.paginate = false\n if params && params[\"paginate\"]\n self.paginate = true\n self.paginate = false if params[\"do_viewall\"]\n elsif params && params[\"viewall\"]\n self.paginate = false\n self.paginate = true if params[\"do_paginate\"]\n end\n \n #--- set up perpage\n if params && params[\"perpage\"]\n self.set_items_per_page(params[:perpage])\n end\n\n params[\"dropdowns\"].each_pair do |name,value|\n dropdowns[name][\"value\"] = value if dropdowns[name]\n end if params && params[\"dropdowns\"] # do params\n \n params[\"custom_fields\"].each_pair do |name,value|\n custom_fields[name][\"value\"] = CUSTOM_DEFAULT_VALUE \n custom_fields[name][\"value\"] = value if custom_fields[name] && value!=CUSTOM_VALUE_FOR_ALL \n end if params && params[\"custom_fields\"] # do params\n \n params[\"boolean_fields\"].each_pair do |name,value|\n boolean_fields[name][\"value\"] = BOOLEAN_VALUE_FOR_ALL \n boolean_fields[name][\"value\"] = value if boolean_fields[name] && value!=BOOLEAN_VALUE_FOR_ALL \n end if params && params[\"boolean_fields\"] # do params\n \n if params[:sort_by] #&& params[:old_sort_by] && params[:old_sort_by_order]\n \n self.sort_by = params[:sort_by]\n self.sort_by_order = params[:old_sort_by_order] == 'ASC' ? 'ASC' : 'DESC'\n if params[:old_sort_by] == params[:sort_by] && params[:sort_by_order_flip] == 'yes'\n self.sort_by_order = params[:old_sort_by_order] == 'DESC' ? 'ASC' : 'DESC' \n end\n \n self.sql_sortorder = \"#{self.sort_by} #{self.sort_by_order}\"\n self.sql_sortorder += \", #{self.secondary_sort}\" unless self.secondary_sort.blank?\n \n end # if sort_order \n \n params[\"dates\"].each_pair do |name,value|\n if dates[name]\n dates[name][\"value\"] = Date.new(\n value[\"date(1i)\"].to_i,\n value[\"date(2i)\"].to_i,\n value[\"date(3i)\"].to_i\n )\n end\n end if params && params[\"dates\"] # do params\n \n self.search_string = RFilter.sanitize_sql(params[\"search_for\"]) if params && params[\"search_for\"]\n\n generate_sql_conditions\n end",
"def reset_fields\n each_field_name do |key|\n reset_field(key)\n end\n end",
"def filtering_params(params)\n\t\t params.slice(:name, :category_id, :trademark)\n\t\tend",
"def filter_params\n params.require(:filter).permit(:template, :name, :code)\n end",
"def parse_filter_params(permitted:)\n # Symbolize the keys so the values can be used with keyword arguments in the filter scopes.\n filter_params = params[:filter].try(:permit, permitted).try(:to_h)\n end",
"def filters=( args )\n @filters.clear\n add_filters(*args)\n end",
"def filtering_params\n params.slice( :title, :location )\n end",
"def parameters(params)\n allowed = [:start,:num,:type,:id,:filter,:tagged,:search,:state,:email,:password]\n params.merge! defaults if defaults\n params.reject {|key,value| !allowed.include? key }\n end",
"def after_update\n super\n clear_instance_filters\n end",
"def inquiry_filter_params\n params.fetch(:inquiry_filter, {})\n end",
"def filter_params\n params.require(:filter).permit(:name, :description, :opt_in)\n end",
"def empty!\n super\n @params = ActiveSupport::OrderedHash.new\n end",
"def clear_fields\n\t\tend",
"def filter_params\n params.fetch(:filter, {}).permit(:text, :type)\n end",
"def filter_params\n params.require(:filter).permit(family: [], number: [], sub_fam: [], sub_num: [], enhancement: [], enh_sub_fam: [], enh_sub_num: [])\n end",
"def unparse_params\n @_unparse_params ? @_unparse_params.dup : nil\n end",
"def filter\n params['filter_field'] || '*'\n end",
"def filters\n end",
"def clean_params params_hsh\n clone = params_hsh.clone\n clone.delete 'splat'\n clone.delete 'captures'\n clone\n end",
"def update_params\n raise 'Sovrascrivi in figli'\n end",
"def initialize_filters(params)\n # integer arrays\n [\n :location_ids,\n :model_ids,\n :scenario_ids,\n :indicator_ids,\n :sector_ids,\n :category_ids\n ].map do |param_name|\n if params[param_name].present? && params[param_name].is_a?(Array)\n value = params[param_name].map(&:to_i)\n end\n instance_variable_set(:\"@#{param_name}\", value)\n end\n @start_year = params[:start_year]&.to_i\n unless @start_year.present? && @start_year > MINIMUM_YEAR_FROM\n @start_year = MINIMUM_YEAR_FROM\n end\n @end_year = params[:end_year]&.to_i\n end",
"def filtering_params(params)\n params.slice(:model_name, :brand_name,:year,:mileage)\n end",
"def update!(**args)\n @composite_filter = args[:composite_filter] if args.key?(:composite_filter)\n @value_filter = args[:value_filter] if args.key?(:value_filter)\n end",
"def update!(**args)\n @composite_filter = args[:composite_filter] if args.key?(:composite_filter)\n @value_filter = args[:value_filter] if args.key?(:value_filter)\n end",
"def normalize_params(params)\n # filters\n conditions = params[:filter] && convert_filters(params[:filter])\n \n normalized_conditions = {}\n conditions && conditions.each_pair do |k, v|\n normalized_conditions.merge!(k.gsub(\"__\", \"_\") => v)\n end\n \n {:conditions => normalized_conditions}\n end",
"def filters\n @filters ||= {}\n end",
"def set_filter_options\n @sort_modes = Organization.sort_modes\n @view_modes = Organization.view_modes\n\n @current_sort_mode = if @sort_modes.keys.include?(params[:sort_by])\n params[:sort_by]\n else\n @sort_modes.keys.first\n end\n\n @current_view_mode = if @view_modes.keys.include?(params[:view])\n params[:view]\n else\n @view_modes.keys.first\n end\n\n @query = params[:query]\n end",
"def filters; end",
"def filters; end"
] |
[
"0.7312239",
"0.72822034",
"0.72426456",
"0.7208308",
"0.7156524",
"0.7128091",
"0.7106637",
"0.7101697",
"0.7072232",
"0.69068617",
"0.6905468",
"0.6870684",
"0.67339295",
"0.67339295",
"0.66478246",
"0.66478246",
"0.66198885",
"0.6570264",
"0.6553955",
"0.65506566",
"0.65091145",
"0.64816546",
"0.6465307",
"0.6436808",
"0.6435697",
"0.642728",
"0.6389256",
"0.63887835",
"0.6383997",
"0.6383997",
"0.6370772",
"0.63678014",
"0.6328449",
"0.6313635",
"0.62921554",
"0.62921554",
"0.62819964",
"0.6278586",
"0.6272762",
"0.624656",
"0.6188056",
"0.6172261",
"0.61704916",
"0.6168889",
"0.61670315",
"0.61540854",
"0.6151116",
"0.612593",
"0.6108023",
"0.6082871",
"0.6041844",
"0.60413355",
"0.6035674",
"0.60279053",
"0.5987459",
"0.59822565",
"0.59706056",
"0.59607506",
"0.59389585",
"0.59379655",
"0.5931712",
"0.59227926",
"0.5905503",
"0.58922607",
"0.58896184",
"0.58882135",
"0.58833385",
"0.587195",
"0.58455133",
"0.5837864",
"0.58343226",
"0.58328587",
"0.5827842",
"0.58214706",
"0.5804634",
"0.5801984",
"0.5801344",
"0.57711047",
"0.576403",
"0.5759872",
"0.5759233",
"0.57575136",
"0.575537",
"0.57544535",
"0.57506734",
"0.5735989",
"0.5719432",
"0.5719125",
"0.57141656",
"0.5707957",
"0.5700842",
"0.5699313",
"0.5699084",
"0.56800306",
"0.56800306",
"0.5676843",
"0.5669111",
"0.5665675",
"0.5662924",
"0.5662924"
] |
0.79791284
|
0
|
create date object with the given integer loop 365 times if date is a friday, and date is the 13th of the month add 1 to unlucky_days variable
|
def friday_13th(year)
date = Date.new(year)
unlucky_days = 0
365.times do
date = date + 1
if date.friday? == true && date.mday == 13
unlucky_days += 1
end
end
unlucky_days
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def make_days\n month = (1..@day_num).collect do |day|\n Day.new(Date.parse(\"#{@year}-#{@month}-#{day}\"))\n end\n\n month[0].date.wday.times { month.insert(0, Day.new(Date.new))}\n month\n end",
"def unlucky_days(year)\r\n (1..12).count { |month| Time.new(year, month, 13).friday? }\r\n end",
"def next_day(date, number_of_day)\n date += 1 + (((number_of_day-1)-date.wday) % 7)\n end",
"def friday_13th(year)\n fridays = 0\n month = 1\n t = Time.new(year, month, 13)\n\n loop do \n fridays +=1 if t.friday?\n month += 1\n month == 13 ? break : t = Time.new(year, month, 13)\n end\n\n fridays\nend",
"def friday_13th(year)\n# Input integer (year)\n# Output integer (count of friday 13ths)\n# create a date obj on jan 13, year\n# step through months, iterate a counter when month 13th is friday\n# return count\n\n count = 0\n month = 1\n date = Date.new(year, month, 13)\n \n loop do\n count += 1 if Date.new(year, month, 13).friday?\n month += 1\n break if month > 12\n end\n\n count\nend",
"def your_birthday_is_on_a_friday_in_the_year(birthday)\n until birthday.friday?\n birthday = Time.new birthday.year + 1, birthday.month, birthday.day\n end\n birthday.year\nend",
"def friday_13th(year)\n thirteenth = Date.new(year, 1, 13)\n count = 0\n 12.times do |month|\n count += 1 if thirteenth.friday?\n thirteenth = thirteenth.next_month\n end\n count\nend",
"def add_days(date, n)\n date + n * DAY\n end",
"def friday_13th(year)\n\n first_of_month = Date.new(year.to_i, 1, 1)\n\n # If January starts on Sunday, the year will have 3 Friday 13ths\n return 3 if first_of_month.sunday?\n\n bad_fridays = 0\n \n 11.times do \n first_of_month = first_of_month.next_month\n bad_fridays += 1 if first_of_month.sunday?\n end\n bad_fridays\nend",
"def friday_13th(year)\n month = 1\n count = 0\n loop do\n count += 1 if Date.new(year, month, 13).friday?\n break if month == 12\n month += 1\n end\n count\nend",
"def five_fridays(year)\n num_days = {\n 1=>31, 2=>28, 3=>31, 4=>30, 5=>31, 6=>30,\n 7=>31, 8=>31, 9=>30, 10=>31, 11=>30, 12=>31\n }\n\n five_fridays = 0\n num_days[2] = 29 if Date.new(year).leap?\n\n 1.upto(12) do |month|\n num_fridays = 0\n 1.upto(num_days[month]) do |day|\n date = Date.new(year, month, day)\n num_fridays += 1 if date.friday?\n end\n five_fridays += 1 if num_fridays >= 5\n end\n\n five_fridays\nend",
"def increment_by_days count\n new_day = @day\n new_month = @month\n new_year = @year \n \n while count > 0\n days_to_next_month = days_in_month(new_month, new_year) - new_day + 1\n \n if (days_to_next_month > count)\n new_day = new_day + count\n count = 0 \n else\n new_day = 1\n new_month = new_month + 1\n if (new_month > 12)\n new_month = 1\n new_year = new_year + 1\n end\n \n count = count - days_to_next_month \n end\n end\n \n return MyDate.new new_day, new_month, new_year\n end",
"def next_working_date(date)\n cwday = date.cwday\n days = 0\n while non_working_week_days.include?(((cwday + days - 1) % 7) + 1)\n days += 1\n end\n date + days\n end",
"def friday_13th(year)\n month = 1\n f13 = 0\n while month < 13\n x = Time.new(year,month,13)\n if x.friday?; f13 += 1 end\n month += 1\n end\n f13\nend",
"def five_fridays(year)\n date = Date.new(year)\n month = 1\n\n month_count = 0\n friday_count = 1\n\n date = date.next_day until date.friday?\n\n while date.year == year\n 7.times { date = date.next_day }\n if date.month == month\n friday_count += 1\n else\n month_count += 1 if friday_count == 5\n friday_count = 1\n month += 1\n end\n end\n month_count\nend",
"def to_fixed(i_date = self)\n year = i_date.year\n week = i_date.week\n day = i_date.day\n nth_kday(week, SUNDAY, Gregorian::Date[year - 1, DECEMBER, 28].fixed) + day\n end",
"def working_days_from_date(date)\r\n date = date + 1.day if date.cwday == 6\r\n day_of_the_week = date.cwday == 7 ? 0 : date.cwday\r\n calendar_days, business_days = self, self\r\n result_date = day_of_the_week + business_days\r\n if (result_date >= 6)\r\n business_days -= (6 - day_of_the_week)\r\n calendar_days += 2\r\n weeks = business_days / 5\r\n calendar_days += (weeks * 2)\r\n end\r\n date + calendar_days.days\r\n end",
"def create_date_value\n \n 1.upto(months.length) do |month|\n 1.upto(month) do |day|\n arr << [\"2015#{day}#{month}\", day_of_week]\n end\n end\nend",
"def new_years_day_for(year)\n nyd = Date.new(year,1,1)\n if nyd.saturday?\n Date.new(year,1,3)\n elsif nyd.sunday?\n Date.new(year,1,2)\n else\n nyd\n end\n end",
"def your_birthday_is_on_a_friday_in_the_year(birthday)\n month = birthday.strftime(\"%m\").to_i\n day = birthday.strftime(\"%d\").to_i\n year = birthday.strftime(\"%Y\").to_i\n loop do\n year = year += 1\n time = Time.new(year, month, day)\n break if time.strftime(\"%u\") == \"5\"\n end\n year\nend",
"def five_fridays(year)\n fridays = Hash.new(0)\n friday = Date.new(year)\n loop do\n break if friday.friday?\n\n friday += 1\n end\n\n while friday.year == year\n fridays[friday.month] += 1\n\n friday += 7\n end\n fridays.values.select { |month| month == 5 }.size\nend",
"def fridays_in_year(year)\n current_week = 1\n current_day = 5\n current_date = DateTime.commercial(year, current_week, current_day)\n fridays_per_month = Array.new(12,0)\n while current_date.year == year\n fridays_per_month[current_date.month - 1] += 1\n current_date += 7\n end\n fridays_per_month\nend",
"def dayOfWeek\n days = 0;\n tempYear = MIN_YEAR\n while tempYear < @year\n days += SimpleDate.daysInYear(tempYear).to_i\n tempYear+=1\n end\n\n days = days + ordinalDate\n #puts \"days #{days}\"\n days = days % 7\n\n end",
"def nwrug_meet_for year, month\n beginning_of_month = Date.civil(year, month, 1)\n nwrug = beginning_of_month + (18 - beginning_of_month.wday)\n nwrug += 7 if beginning_of_month.wday > 4\n\n # Make sure we skip to the next month if we've gone past this month's meet\n if nwrug < Date.today\n if month == 12\n month = 1\n year += 1\n else\n month += 1\n end\n nwrug = nwrug_meet_for year, month\n end\n\n nwrug\nend",
"def friday_13th(year)\n count_of_friday_13th = 0\n 1.upto(12) do |month|\n t = Time.local(year, month, 13)\n count_of_friday_13th += 1 if t.friday?\n end\n count_of_friday_13th\nend",
"def friday_13th_2(yr)\n 1.upto(12).count { |mon| Time.new(yr, mon, 13).friday? }\nend",
"def friday_13th(year)\n (1..12).count { |month| Date.new(year, month, 13).friday? }\nend",
"def add_days(number)\n if number < 0\n return sub_days(number.abs)\n end\n o = dup # new ZDate object\n # Let's see what month we are going to end in\n while number > 0\n if o.days_left_in_month >= number\n o.date = ZDate.format_date(o.year_str, o.month_str, o.day + number)\n number = 0\n else\n number = number - 1 - o.days_left_in_month # it costs 1 day to increment the month\n o.increment_month!\n end\n end\n o\n end",
"def next_weekday(weekday = 2)\n date = Date.today\n unless date.strftime(\"%w\") == weekday.to_s\n date += 1 + ((weekday -1 -date.wday) % 7)\n end\n date\n end",
"def next!\n if @date.month + 1 > 12\n @date = Date.new(@date.year+1,@date.month,1)\n else\n @date = Date.new(@date.year,@date.month+1,1)\n end\n end",
"def friday_13th(year)\n days = %w(Sunday Monday Tuesday Wednesday Thursday Friday Saturday)\n days_in_month = {'January' => 31, 'February' => 28, 'March' => 31, 'April' => 30, \n 'May' => 31, 'June' => 30, 'July' => 31, 'August' => 31, \n 'September' => 30, 'October' => 31, 'November' => 30, 'December' => 31}\n years = (1753...year).to_a\n total_days = years.map do |year|\n if leap_year?(year)\n 366\n else\n 365\n end\n end\n day = total_days.reduce(:+) % 7\n\n jan_1st_of_year = day + 1\n\n days_in_month['February'] = 29 if leap_year?(year)\n first_of_month = [jan_1st_of_year]\n\n carry_over = jan_1st_of_year\n\n days_in_month.each do |month, days|\n next if month == 'December'\n first_of_month << (days + first_of_month[-1]) % 7\n end\n first_of_month.map! do |day|\n days[day]\n end\n number_of_friday_13ths = first_of_month.select do |day|\n day == 'Sunday'\n end\n number_of_friday_13ths.count\nend",
"def friday_13th(year)\n require \"Date\"\n num_of_fri_13ths = 0\n months = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n months.each {|month| num_of_fri_13ths += 1 if Date.new(year, month, 13).friday?}\n num_of_fri_13ths\nend",
"def friday_13th(yr)\n total = 0\n 1.upto(12) { |mon| total += 1 if Time.new(yr, mon, 13).friday? }\n total\nend",
"def next_day(date)\n date + (60 * 60 * 24)\n end",
"def cutoff_date\n case date.wday\n when 0\n date + (weeks.to_i * 7)\n when 1\n date + (weeks.to_i * 7) - 1\n when 2\n date + (weeks.to_i * 7) - 2\n when 3\n date + (weeks.to_i * 7) - 3\n when 4\n date + (weeks.to_i * 7) - 4\n when 5\n date + (weeks.to_i * 7) - 5\n when 6\n date + (weeks.to_i * 7) + 1\n end\n end",
"def friday_13th?(year)\n fridays = 0\n 1.upto(12) do |month|\n fridays += 1 if Time.new(year, month, 13).friday?\n end\n fridays\nend",
"def to_weekday_if_boxing_weekend(date)\n if date.wday == 6 || date.wday == 0\n date += 2\n elsif date.wday == 1\n date += 1\n end\n\n date\n end",
"def add_working_days(date, working_days)\n if working_days > 0\n weeks = working_days / (7 - non_working_week_days.size)\n result = weeks * 7\n days_left = working_days - weeks * (7 - non_working_week_days.size)\n cwday = date.cwday\n while days_left > 0\n cwday += 1\n unless non_working_week_days.include?(((cwday - 1) % 7) + 1)\n days_left -= 1\n end\n result += 1\n end\n next_working_date(date + result)\n else\n date\n end\n end",
"def to_calendar(date = self.fixed)\n approx = Gregorian::Date[date - 3].year #gregorian_year_from_fixed(date - 3)\n year = date >= date(approx + 1, 1, 1).fixed ? approx + 1 : approx\n week = 1 + quotient(date - date(year, 1, 1).fixed, days_in_week)\n day = amod(date - rd(0), 7)\n Date.new(year, week, day)\n end",
"def your_birthday_is_on_a_friday_in_the_year(birthday)\n while birthday.friday? == false\n birthday += (60 * 60 * 24 * 365)\n end\n birthday.year\n # rspec was after a year, but the question was asking for a day\n # not the clearest of questions. Should state \"someones\" bday, not\n # the users\nend",
"def future(year, month, day)\n years = (10 ** 9) / 60 / 60 / 24 / 365\n days = (10 ** 9) / 60 / 60 / 24 % 365\n\n year = year + years\n \n\nend",
"def fiscal_new_year_date(date = Date.current)\n Date.new(calculate_fiscal_year(date),05,01)\n end",
"def month_weekday_date(date, skip, wday, week_shift)\n calc_next_at = (date.beginning_of_month) + skip.month#+ skip.month\n calc_next_at += 1.day until WEEKDAYS[calc_next_at.wday] == wday # find 1st selected weekday in a month\n calc_next_at = calc_next_at + week_shift.week # shifts to 1st/2nd/3rd/4th week\n calc_next_at\n end",
"def friday_13th(year)\n count = 0\n 1.upto(12) do |month|\n count += 1 if Time.new(year, month, 13).friday?\n end\n count\nend",
"def each_friday( n=1, offset=0, dur=1); each_wdays(self.Fri,n,offset,dur); end",
"def days(num)\n # date calculated as the offset from midnight tommorrow. Zero will provide values for all times \n # today.\n d = Date.today + num\n {\n :type => :date,\n :value => d.strftime(STRFTIME_DATE_FORMAT)\n }\n end",
"def to_calendar(f_date = self.fixed)\n approx = quotient(((4 * (f_date - epoch))) + 1464, 1461)\n yyear = approx <= 0 ? approx - 1 : approx\n prior_days = f_date - date(yyear, JANUARY, 1).fixed\n correction = if f_date < date(yyear, MARCH, 1).fixed\n 0\n elsif Julian::Year[yyear].leap_year?\n 1\n else\n 2\n end\n mmonth = quotient(12*(prior_days + correction) + 373, 367)\n dday = 1 + (f_date - date(yyear, mmonth, 1).fixed)\n Calendrical::Calendar::Date.new(yyear, mmonth, dday)\n end",
"def add_days(count)\n 24*60*60*count.to_i\n end",
"def sub_days(number)\n o = dup\n while number > 0\n if (o.day - 1) >= number\n o.date = ZDate.format_date(o.year_str, o.month_str, o.day - number)\n number = 0\n else\n number -= o.day\n o.decrement_month!\n end\n end\n o\n end",
"def forward(from: ::Date.today, days: 365)\n start_date = get_date_object(from)\n since = start_date + 1\n to = start_date + days\n\n between(from: since, to: to).to_date\n end",
"def next_game_date(date_time, wday)\n date_time += 1 until (wday == date_time.wday &&\n !@exclude_dates.include?(date_time)) || @include_dates.include?(date_time)\n date_time\n end",
"def to_calendar(f_date = self.fixed)\n new_year = new_year_on_or_before(f_date)\n yyear = ((new_year - epoch) / MEAN_TROPICAL_YEAR).round + 1\n mmonth = quotient(f_date - new_year, 30) + 1\n dday = ((f_date - new_year) % 30) + 1\n self.class::Date.new(yyear, mmonth, dday)\n end",
"def your_birthday_is_on_a_friday_in_the_year(birthday)\n # Key: tells you the YEAR where birthday will be on a Fri\n # each year = moves up 2 days\n loop {\n if birthday.friday? == true\n return birthday.year\n end\n # key -> don't need to account for day of week change in addition, only 1 year onwards - the .friday? will work out what day of the week it is\n birthday = birthday + (365*24*60*60) }\nend",
"def addDays(date)\n\n #puts 'in addDays'\n #puts date\n if date.saturday? then\n #puts \"sat\"\n date1 = date.next_day(7)\n return date1\n elsif date.sunday? then\n #puts \"sun\"\n date1 = date.next_day(8)\n return date1\n else\n #puts 'other'\n date1 = date.next_day(7)\n end\n return date1\n end",
"def sundayCounter\n days = [31,28,31,30,31,30,31,31,30,31,30,31]\n date, sundays = 0, 1\n\n (1901...2000).each do\n (0..11).each do |month|\n date = (date + days[month]) % 7\n sundays += 1 if date == 6\n end\n end\n sundays\nend",
"def end_date\n Date.new((@number + 1), 1, 1).tuesday? ? Date.new((@number + 1), 1, 1) : Date.new(@number, 12, 31)\n end",
"def next_weeks_open_house_dates(open_house_dow)\n now = Time.now\n dates = []\n (0...7).each do |day_offset|\n days = day_offset*24*60*60\n date = now + days\n if open_house_dow.include?(date.wday)\n dates << now + days\n end\n end\n dates\n end",
"def first_wday; (wday - day + 1) % 7 end",
"def date\n calc_date = self.day % 30\n calc_date == 0 ? 30 : calc_date\n end",
"def day_of_week\n dnum = day\n dnum -= 10 if dnum > 20\n dnum -= 10 if dnum > 10\n dnum -= 1\n dnum\n end",
"def to_fixed(g_date = self)\n mmonth = g_date.month\n dday = g_date.day\n yyear = g_date.year\n ((epoch - 1) + \n (365 * (yyear - 1)) + \n quotient(yyear - 1, 4) - \n quotient(yyear - 1, 100) + \n quotient(yyear - 1, 400) + \n quotient((367 * mmonth) - 362, 12) +\n (if mmonth <= 2\n 0\n elsif leap_year?(yyear)\n -1\n else\n -2\n end) + \n dday)\n end",
"def to_fixed(fr_date = self)\n mmonth = fr_date.month\n dday = fr_date.day\n yyear = fr_date.year\n new_year = new_year_on_or_before((epoch + 180 + MEAN_TROPICAL_YEAR * (yyear - 1)).floor)\n new_year - 1 + 30 * (mmonth - 1) + dday\n end",
"def next_game_date(dt, wday)\n dt += 1 until (wday == dt.wday && !@exclude_dates.include?(dt)) || @include_dates.include?(dt)\n dt\n end",
"def initialize(month, start_date)\n @start_date = start_date\n raise(ArgumentError, \"Must start on Sunday\") if start_date.wday != 0\n\n @days = []\n (start_date..start_date + 6).each do |date|\n @days << Day.new(month, date)\n end\n end",
"def next_anniversary_date\n while (@due_date <= Date.today)\n @due_date = Date.new(@year += 1, @month, @day)\n end\n end",
"def initialize(d=Date.today)\n if d.instance_of? Time\n rd = Date.civil(d.year, d.month, d.day)\n elsif d.instance_of? DateTime\n rd = Date.jd(d.jd)\n else\n rd = d.dup # always make a duplicate before modifying arguments\n end\n raise ArgumentError, \"Must pass Date, DateTime, or Time object\" unless rd.instance_of? Date\n @attachments = []\n @days = []\n rd -= 1 while rd.wday > 0\n # puts \"Got past first while\"\n # puts rd\n @days << rd\n for i in (1...7)\n @days[i] = (rd + i)\n end\n # puts \"Got past for\"\n @days.freeze\n end",
"def future_date(days)\n Faker::Date.forward(days)\n end",
"def working_date(date)\n offset = case date.wday\n when 2..6 then 1\n when 1 then 3\n when 0 then 2\n end\n\n date - offset\n end",
"def date_end # originally date_start\n\tdate = Date.today\n\t(1..7).each do |n|\n\t\tdate = Date.today - n#.days\n\t\tbreak if date.wday == 6 # 0 = Sun, 1 = Mon ... 6 = Sat\n\tend\n\tdate\nend",
"def days_until_xmas(date = Date.today)\n xmas_day = Date.new(date.year, 12, 25)\n if xmas_day < date\n xmas_day = xmas_day.next_year\n end\n (xmas_day - date).to_i\nend",
"def fauxify!\n # cleanup the old ones\n self.delete_all\n # instantiate beginning date\n date = 13.months.ago.to_date\n # loop through the days till today\n cutoff_date = Date.parse(\"23/11/2012\")\n until date == cutoff_date\n # skip weekends\n unless (date.saturday? || date.sunday?)\n # choose a random number of entries between 3 and 25\n number_of_entries = (3..25).to_a.sample\n # create the given number of entries\n number_of_entries.times do\n hour = (9..17).to_a.sample\n minute = (0..59).to_a.sample\n # choose a random time in the day between 09:00 and 17:30 and a random happiness value\n entered_at = DateTime.parse(\"#{date} #{hour}:#{minute}\")\n # happiness_value = HappinessValue[]\n entry_date = entered_at.to_date\n entry_time = entered_at.to_time\n uid = entered_at.to_i\n happiness_entry = self.create(:uid => uid, :entry_date => entry_date, :entry_time => entry_time, :happiness_value => [1,1,1,2,3].sample) unless happiness_entry\n end\n end\n date = date + 1.day\n end\n end",
"def date\n (birthday.to_time + 10**9).to_date\n end",
"def birthday_wish(num)\n bday = Date.parse(num)\n present_date = Date.today\n days_away = (bday - present_date) % 365\n days_away.to_i\nend",
"def to_weekday_if_weekend(date)\n date += 1 if date.wday == 0\n date -= 1 if date.wday == 6\n date\n end",
"def date_of_next(day)\r\n date = Date.parse(day)\r\n delta = date > Date.today ? 0 : 7\r\n date + delta\r\nend",
"def next_birthday\n year = current_year + 1\n\n return Date.new(year, date_of_birth.month, date_of_birth.day) if beyond_birth_month?\n\n return Date.new(year, date_of_birth.month, date_of_birth.day) if beyond_birth_day_within_birth_month?\n\n Date.new(year - 1, date_of_birth.month, date_of_birth.day)\n end",
"def forward(days = 365)\n from = ::Date.today + 1\n to = ::Date.today + days\n\n between(from, to)\n end",
"def date_of_next(day)\n date = Date.parse(day)\n delta = date > Date.today ? 0 : 7\n date + delta\nend",
"def date_of_next(day)\n date = Date.parse(day)\n delta = date > Date.today ? 0 : 7\n date + delta\n end",
"def alt_to_calendar(date)\n y = to_calendar(gregorian_epoch - 1 + date + 306)\n prior_days = date - to_fixed(date(y - 1, MARCH, 1))\n month = amod(quotient(5 * prior_days + 2, 153) + 3, 12)\n year = y - quotient(month + 9, 12)\n day = date - to_fixed(date(year, month, 1)) + 1\n date(year, month, day)\n end",
"def days(number_of_days)\n # date calculated as the offset from midnight tommorrow. Zero will provide values for all times\n # today.\n d = current_date + number_of_days\n {\n type: :date,\n value: d.strftime(STRFTIME_DATE_FORMAT)\n }\n end",
"def sweetmorn(date, parameter=nil)\n date = _to_date_for_note(date)\n y,m,d = date.cal_date\n date -= When::P1D if date.length(When::MONTH) == 74 && +d == 60\n dow = ((m-1)*73+d*1-1) % 5\n date -= When::P1D * dow unless dow == 0\n date.events = [@days_of_week[0]]\n date\n end",
"def sunday_after days_ago=0\n d = Date.today - days_ago\n until d.sunday?\n d += 1\n end\n d\nend",
"def five_friday(year)\n month_count = 0\n 1.upto(12) do |month|\n fridays = Date.new(year, month, 1).step(Date.new(year, month, -1)).select { |day| day.friday? }.size\n month_count += 1 if fridays == 5\n end\n month_count\nend",
"def nth_wday; (day - 1) / 7 end",
"def to_calendar(f_date = self.to_fixed)\n yyear = year_from_fixed(f_date)\n prior_days = f_date - Gregorian::Date[yyear, 1, 1].fixed\n correction = (if f_date < date(yyear, MARCH, 1).fixed\n 0\n elsif leap_year?(yyear)\n 1\n else\n 2\n end)\n month = quotient((12 * (prior_days + correction)) + 373, 367)\n day = 1 + f_date - date(yyear, month, 1).fixed\n Calendrical::Calendar::Date.new(yyear, month, day)\n end",
"def jwday\n (to_g.wday + 1) % 7\n end",
"def next_weekday(date, weekdays)\n [weekdays].flatten.map{|wd| \n nwd = date - date.cwday + Date::WEEKDAYS.index(wd) + 1\n nwd += 7 if nwd <= date\n nwd\n }.sort[0]\n end",
"def endless_numbered_days(year=2011,month=1)\n x = Date.new(year,month,-1).day\n y = Date.new(year,month,1).wday\n cal = {}\n 1.upto(x) do |i|\n cal[i] = [y]\n y += 1\n end\n return cal.to_json\n end",
"def nwday_day(n)\n w = n % 7\n 1 + (w - (wday - day + 1)) % 7 + n - w\n end",
"def to_monday_if_sunday(date)\n date += 1 if date.wday == 0\n date\n end",
"def start_date\n @start_date ||= Date.today - Date.today.wday - 7 * 52\nend",
"def new_year(date) = ::Date.new(Integer === date ? date : date(date).year, 1, 1, reform_jd).new_start(::Date::GREGORIAN)",
"def five_friday_months(year)\n fridays_in_month = [0] * 12\n 1.upto(12) do |month|\n 1.upto(31) do |day|\n t = Time.new(year, month, day)\n fridays_in_month[month - 1] += 1 if t.month == month && t.friday?\n end\n end\n 1.upto(12).select { |idx| fridays_in_month[idx - 1] == 5 }\nend",
"def backward(days: 365)\n from = ::Date.today - days\n to = ::Date.today - 1\n\n between(from: from, to: to).to_date\n end",
"def date_of_next(day)\n date = Date.parse(day)\n delta = date > Date.today ? 0 : 7\n\n return date + delta\n end",
"def each_july( n=1); each_monthnum(self.Jul,n); end",
"def tomorrow(x = 1)\n\t\tself + (86400 * x)\n\tend",
"def next_birthday\n today = Time.new\n if @date_of_birth.month - today.month <= 0 && @date_of_birth.day - today.day < 0 || @date_of_birth.month - today.month < 0\n Date.new(today.year + 1, @date_of_birth.month, @date_of_birth.day)\n elsif @date_of_birth.month - today.month == 0 && @date_of_birth.day - today.day == 0\n \"Happy Birthday!\"\n else\n Date.new(today.year, @date_of_birth.month, @date_of_birth.day)\n end\n end",
"def nwday_of_month(n)\n self + (nwday_day(n) - day).days\n end"
] |
[
"0.66368306",
"0.6629865",
"0.6624537",
"0.6605464",
"0.65711623",
"0.6459968",
"0.63914263",
"0.63739103",
"0.6373012",
"0.6337704",
"0.63307947",
"0.61945593",
"0.617135",
"0.61478686",
"0.61069566",
"0.61055416",
"0.6056321",
"0.6031889",
"0.60201555",
"0.600777",
"0.6005133",
"0.59916055",
"0.59551734",
"0.59332585",
"0.59328914",
"0.59283257",
"0.5911955",
"0.5875039",
"0.5870241",
"0.5858959",
"0.5851859",
"0.5851849",
"0.58480084",
"0.5841166",
"0.5828405",
"0.58197755",
"0.58086085",
"0.5803776",
"0.58020115",
"0.5782637",
"0.5758882",
"0.5756363",
"0.57314855",
"0.57219124",
"0.5717821",
"0.57170767",
"0.5697848",
"0.5693932",
"0.5692966",
"0.5692504",
"0.56879133",
"0.5685776",
"0.5649629",
"0.5627131",
"0.5606316",
"0.56057745",
"0.5605479",
"0.5601443",
"0.5600031",
"0.5580038",
"0.55778337",
"0.556696",
"0.5564789",
"0.556248",
"0.55588025",
"0.5554552",
"0.55390954",
"0.55358255",
"0.5528777",
"0.55271477",
"0.55264974",
"0.551982",
"0.55161977",
"0.54967487",
"0.5491891",
"0.54489577",
"0.5437513",
"0.5433528",
"0.5433077",
"0.5422651",
"0.5418769",
"0.54131824",
"0.540034",
"0.5397373",
"0.53909093",
"0.53862727",
"0.5378036",
"0.53770006",
"0.53745675",
"0.53557456",
"0.5355306",
"0.53511935",
"0.5349711",
"0.53466827",
"0.5345333",
"0.5344377",
"0.5339612",
"0.5338501",
"0.5336645",
"0.5330463"
] |
0.7075502
|
0
|
Context Tools Used to call pdb functions which change or retrieve information about context features within gimp Flushes displays so that the images displayed in windows are up to date
|
def context_update_displays!()
$gimp_iface.gimp_displays_flush()
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def features\n features = {}\n sexp_newtype_block.each do |s|\n if s[0] == :command and\n s[1][0..1] == [:@ident, \"feature\"] and\n s[2][0] == :args_add_block\n\n name = s[2][1][0][1][1][1]\n desc = s[2][1][1][1][1][1]\n\n features[name] = desc\n end\n end\n\n features\n end",
"def features\n features = Hash[api.get_features(app).body.map{|feature| [feature['name'], feature['enabled']]}]\n actual_features = Hash[api.get_features(target_app).body.map{|feature| [feature['name'], feature['enabled']]}]\n\n features_to_enable = features.select{|feature, enabled| enabled && !actual_features[feature]}\n features_to_disable = actual_features.select{|feature, enabled| enabled && !features[feature]}\n\n action(\"Copying labs features from #{app} and restarting #{target_app}\") do\n features_to_enable.each do |feature|\n puts \"Adding #{feature} to #{target_app}\"\n api.post_feature(feature, target_app)\n end\n\n features_to_disable.each do |feature|\n puts \"Deleting #{feature} from #{target_app}\"\n api.delete_feature(feature, target_app)\n end\n end\n end",
"def context_pin; end",
"def draw_feature( image, feature, x, y )\n if feature.feature_type == \"exon\" and not feature.feature_name.match(/En2/)\n if feature.feature_name.match(/fragment/)\n draw_exon_fragment( image, x, y )\n else\n draw_exon( image, x, y )\n end\n elsif feature.feature_type == \"promoter\"\n draw_promoter( image, feature, [x, y] )\n else\n case feature.feature_name\n when \"FRT\"\n draw_frt( image, feature, x, y )\n when \"loxP\"\n draw_loxp( image, feature, x, y )\n when \"Rox\"\n draw_rox( image, feature, x, y )\n when \"AttP\"\n draw_attp( image, feature, x, y )\n when \"intervening sequence\"\n draw_intervening_sequence( image, x, y )\n when \"F3\"\n draw_f3( image, feature, x, y )\n when \"AsiSI\"\n draw_asisi( image, feature, [x, y] )\n when \"ori\"\n draw_ori( image, x, y )\n when \"En2 SA (ATG)\"\n draw_en2_k_frame( image, feature, [x, y] )\n when \"PGK_DTA_pA\"\n draw_pgk_dta_pa( image, feature, [x, y] )\n when \"pA_DTA_PGK\"\n draw_pa_dta_pgk( image, feature, [x, y] )\n # Any non-speciall feature is probably a cassette feature\n # and can be rendered with the feature.render_options()\n else\n draw_cassette_feature( image, feature, x, y )\n end\n end\n end",
"def context_get_brush()\n return $gimp_iface.gimp_context_get_brush()[0]\nend",
"def usage\n STDERR.puts \"Usage: context [use|view|set]\"\n exit 1\nend",
"def each( context, reference, properties = nil, want_instance = false )\n result = Cmpi::CMPIObjectPath.new reference.namespace, \"RCP_ShowContext\"\nSTDERR.puts \"*** result #{result}\"\n if want_instance\n result = Cmpi::CMPIInstance.new result\nSTDERR.puts \"*** result #{result}\"\n end\n result.name = \"CMPIContext\"\n unless want_instance\n yield result\n return\n end\n \n # Instance: Set non-key properties\n count = context.get_entry_count\n res = []\n i = 0\n while i < count\n name, data = context[i]\n i += 1\n res << name\n res << data.to_s\n end\n # Set key properties\nSTDERR.puts \"res #{res.inspect}\" \n result.context = res # string[] (-> RCP_ShowContext)\n \n yield result\n 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 display_features\n puts\n puts \"Features:\"\n @features.each { |feature| puts \" * #{feature}\"}\n puts\n end",
"def test04()\n begin\n origModes = \"kCGBlendModeNormal kCGBlendModeMultiply kCGBlendModeScreen \"+\n \"kCGBlendModeOverlay kCGBlendModeDarken kCGBlendModeLighten \" + \n \"kCGBlendModeColorDodge kCGBlendModeColorBurn kCGBlendModeSoftLight \" +\n \"kCGBlendModeHardLight kCGBlendModeDifference kCGBlendModeExclusion \" +\n \"kCGBlendModeHue kCGBlendModeSaturation kCGBlendModeColor \" +\n \"kCGBlendModeLuminosity kCGBlendModeClear kCGBlendModeCopy \" +\n \"kCGBlendModeSourceIn kCGBlendModeSourceOut kCGBlendModeSourceAtop \" +\n \"kCGBlendModeDestinationOver kCGBlendModeDestinationIn \" +\n \"kCGBlendModeDestinationOut kCGBlendModeDestinationAtop kCGBlendModeXOR \" +\n \"kCGBlendModePlusDarker kCGBlendModePlusLighter\"\n blendModes = MIMeta.listcgblendmodes\n unless origModes.eql? blendModes\n raise \"Blend modes are different, new:\" + blendModes\n end\n\n origPresets = \"AlphaOnly8bpcInt Gray8bpcInt Gray16bpcInt Gray32bpcFloat \" +\n \"AlphaSkipFirstRGB8bpcInt AlphaSkipLastRGB8bpcInt \"+\n \"AlphaPreMulFirstRGB8bpcInt AlphaPreMulBGRA8bpcInt AlphaPreMulLastRGB8bpcInt \" +\n \"AlphaPreMulLastRGB16bpcInt AlphaSkipLastRGB16bpcInt \" +\n \"AlphaSkipLastRGB32bpcFloat AlphaPreMulLastRGB32bpcFloat \" +\n \"CMYK8bpcInt CMYK16bpcInt CMYK32bpcFloat PlatformDefaultBitmapContext\"\n presets = MIMeta.listpresets\n unless origPresets.eql? presets\n raise \"Presets are different, new:\" + presets\n end\n\n origCommands = [:getproperty, :setproperty, :getproperties, :setproperties,\n :create, :close, :closeall, :addimage, :export, :drawelement, :snapshot,\n :finalizepage, :getpixeldata, :calculategraphicsizeoftext, :renderfilterchain,\n :assignimagetocollection, :removeimagefromcollection, :processframes,\n :createtrack, :addinputtowriter, :addimagesampletowriter,\n :finishwritingframes, :cancelwritingframes, :addmovieinstruction,\n :inserttracksegment, :insertemptytracksegment]\n\n commands = MIMeta.listallcommands\n unless origCommands.eql? commands\n raise \"Command lists are different, new:\" + commands.to_s\n end\n\n origObjects = [:bitmapcontext, :imageimporter, :imageexporter,\n :imagefilterchain, :pdfcontext, :nsgraphiccontext,\n :movieimporter, :movieeditor, :videoframeswriter]\n objectTypes = MIMeta.listobjecttypes\n\n unless origObjects.eql? objectTypes\n raise \"List of objects is different, new:\" + commands.to_s\n end\n\n origInputVideoWriterPresets = \"h264preset_sd jpegpreset h264preset_hd \" +\n \"prores4444preset prores422preset\"\n \n videoWriterPresets = MIMeta.listvideoframewriterpresets\n unless origInputVideoWriterPresets.eql? videoWriterPresets\n raise \"List of video writer presets is different, new:\" + videoWriterPresets.to_s\n end\n\n origUserInterfaceFonts = \"kCTFontUIFontMiniEmphasizedSystem \" +\n \"kCTFontUIFontSmallToolbar kCTFontUIFontWindowTitle \" +\n \"kCTFontUIFontMenuTitle kCTFontUIFontSystem kCTFontUIFontMenuItem \" +\n \"kCTFontUIFontEmphasizedSystem kCTFontUIFontToolbar kCTFontUIFontMessage \" +\n \"kCTFontUIFontEmphasizedSystemDetail kCTFontUIFontSmallEmphasizedSystem \" +\n \"kCTFontUIFontUserFixedPitch kCTFontUIFontMiniSystem kCTFontUIFontLabel \" +\n \"kCTFontUIFontControlContent kCTFontUIFontSystemDetail kCTFontUIFontViews \"+\n \"kCTFontUIFontUser kCTFontUIFontSmallSystem kCTFontUIFontApplication\" +\n \"kCTFontUIFontToolTip\"\n \n userInterfaceFonts = MIMeta.listuserinterfacefonts\n unless userInterfaceFonts.eql? userInterfaceFonts\n raise \"User iterface fonts are different, new:\" + userInterfaceFonts\n end\n\n rescue RuntimeError => e\n $errorcode = Smig.exitvalue\n unless $errorcode.zero?\n puts \"Exit string: #{Smig.get_exitstring}\"\n end\n puts e.message\n puts e.backtrace.to_s\n puts #{Smig.exitstring}\"\n# exit 240\n end\nend",
"def context\n Byebug.current_context\n end",
"def _context_set_fgcolor!(rgb)\n $gimp_iface.gimp_context_set_foreground(rgb)\nend",
"def context_methods; end",
"def _context_set_brush!(brush_name)\n $gimp_iface.gimp_context_set_brush(brush_name)\nend",
"def __bb_context; end",
"def context_get_fgcolor()\n return $gimp_iface.gimp_context_get_foreground()[0]\nend",
"def use_technology_preview=(_arg0); end",
"def genCurrentLayer\n end",
"def main\n ImageManip::inspect_image(@image_path)\n dimensions = ImageManip::get_dimensions(@image_path)\n sharp_pixels = get_accidental_pixels(@sharp_path)\n flat_pixels = get_accidental_pixels(@flat_path)\n edits = Hash.new\n edits[:lower_left] = [dimensions[0] / 2, dimensions[1] / 2]\n edits[:rgb_array] = sharp_pixels\n ImageManip::draw_2D_object(@image_path, './new_staff.gif', edits)\n edits[:lower_left] = [dimensions[0] / 3, dimensions[1] / 3]\n edits[:rgb_array] = flat_pixels\n ImageManip::draw_2D_object('./new_staff.gif', './new_staff.gif', edits)\n end",
"def describe_context(context)\n @current_context = context\n end",
"def debug_context_change\n Ruby.primitive :task_get_debug_context_change\n Kernel.raise PrimitiveFailure, \"primitive failed\"\n end",
"def _context_set_bgcolor!(rgb)\n $gimp_iface.gimp_context_set_background(rgb)\nend",
"def devtools_identifier; end",
"def loaded_features; end",
"def use_technology_preview; end",
"def context_get_bgcolor()\n return $gimp_iface.gimp_context_get_background()[0]\nend",
"def cntrl_cmnd; det.image(:id, 'imgCtrlCommands'); end",
"def lookup_context; end",
"def lookup_context; end",
"def lookup_context; end",
"def update_features\n self.feature_descriptions = BasketItem.describe_feature_selections(feature_selections)\n end",
"def dbtools_usage\n puts \"Available Options for Database Tools Menu: \".underline.white\n puts \"back \".light_yellow + \" => \".white + \"Return to Main Menu\".light_red\n# puts \"mssqlc \".light_yellow + \" => \".white + \"MS-SQL Client\".light_red\n# puts \"mssql_login \".light_yellow + \" => \".white + \"MS-SQL Login Bruter\".light_red\n puts \"mysql-fu \".light_yellow + \" => \".white + \"MySQL-Fu Client Tool\".light_red\n puts \"mysql_check \".light_yellow + \" => \".white + \"MySQL Credential Check\".light_red\n puts \"mysql_login \".light_yellow + \" => \".white + \"MySQL Login\".light_red\n puts \"auth_bypass \".light_yellow + \" => \".white + \"MySQL Auth Bypass Exploit (CVE-2012-2122)\".light_red\n puts \"mysql_mof \".light_yellow + \" => \".white + \"Windows MySQL Privileged User to SYSTEM MOF Exploit\".light_red\n puts \"mysql_udf \".light_yellow + \" => \".white + \"Windows MySQL Privileged User to SYSTEM UDF Exploit\".light_red\n print_line(\"\")\nend",
"def test02()\n begin\n tempFile = nil\n baseImageName = \"DSCN0749-Bloom.jpg\"\n inputImageFile = File.join($directory, \"images/DSCN0749.JPG\")\n theCommands = CommandModule::SmigCommands.new\n theCommands.saveresultstype = :lastcommandresult\n objectName = SecureRandom.uuid\n makeImporterCommand = CommandModule.make_createimporter(inputImageFile,\n name: objectName)\n importerObject = SmigIDHash.make_objectid(objecttype: :imageimporter,\n objectname: objectName)\n theCommands.add_command(makeImporterCommand)\n theCommands.add_tocleanupcommands_closeobject(importerObject)\n \n objectName = SecureRandom.uuid\n imageDims = SpotlightCommand.get_imagedimensions(inputImageFile)\n makeWindowContextCommand = CommandModule.make_createwindowcontext(\n width: imageDims[:width],\n height: imageDims[:height],\n borderlesswindow: true,\n name: objectName)\n windowObject = SmigIDHash.make_objectid(objecttype: :nsgraphicscontext,\n objectname: objectName)\n theCommands.add_command(makeWindowContextCommand)\n theCommands.add_tocleanupcommands_closeobject(windowObject)\n drawImageElement = MIDrawImageElement.new\n drawImageElement.set_imagefile_imagesource(source_object: importerObject,\n imageindex: 0)\n imageDims = SpotlightCommand.get_imagedimensions(inputImageFile)\n destRect = MIShapes.make_rectangle(size: imageDims)\n drawImageElement.destinationrectangle = destRect\n drawElementCommand = CommandModule.make_drawelement(windowObject,\n drawinstructions: drawImageElement)\n theCommands.add_command(drawElementCommand)\n filterChain = MIFilterChain.new(windowObject)\n \n filter = MIFilter.new(:CIBloom)\n radiusProperty = MIFilterProperty.make_cinumberproperty(key: :inputRadius,\n value: 20.0)\n filter.add_property(radiusProperty)\n intensityProperty = MIFilterProperty.make_cinumberproperty(\n key: :inputIntensity, value: 0.6)\n filter.add_property(intensityProperty)\n importerObject[:imageindex] = 0\n inputImageProp= MIFilterProperty.make_ciimageproperty(value: importerObject)\n filter.add_property(inputImageProp)\n filterChain.add_filter(filter)\n filterChainObjectName = SecureRandom.uuid\n filterChainObject = SmigIDHash.make_objectid(objecttype: :imagefilterchain,\n objectname: filterChainObjectName)\n makeFilterChainCommand = CommandModule.make_createimagefilterchain(\n filterChain,\n name: filterChainObjectName)\n theCommands.add_command(makeFilterChainCommand)\n theCommands.add_tocleanupcommands_closeobject(filterChainObject)\n renderFilterChain = MIFilterChainRender.new\n theRect = MIShapes.make_rectangle(xloc: \"0.25 * $imagewidth\",\n yloc: \"0.33 * $imageheight\",\n width: \"0.5 * $imagewidth\",\n height: \"0.4 * $imageheight\")\n variables = { :imagewidth => imageDims[:width],\n :imageheight => imageDims[:height] }\n renderFilterChain.sourcerectangle = theRect\n renderFilterChain.destinationrectangle = theRect\n# renderFilterChain.variables = variables\n makeRenderFilterChainCommand = CommandModule.make_renderfilterchain(\n filterChainObject, renderinstructions: renderFilterChain,\n createimage: true)\n theCommands.add_command(makeRenderFilterChainCommand)\n theCommands.variables = variables\n exporterName = SecureRandom.uuid\n pathtofile = File.join(Dir.tmpdir(), baseImageName)\n createExporterCommand = CommandModule.make_createexporter(pathtofile,\n export_type: :\"public.jpeg\",\n name: exporterName)\n exporterObject = SmigIDHash.make_objectid(objecttype: :imageexporter,\n objectname: exporterName)\n theCommands.add_command(createExporterCommand)\n theCommands.add_tocleanupcommands_closeobject(exporterObject)\n addImageToExporterCommand = CommandModule.make_addimage(exporterObject, \n windowObject, imageindex: 0)\n theCommands.add_command(addImageToExporterCommand)\n exportCommand = CommandModule.make_export(exporterObject)\n theCommands.add_command(exportCommand)\n Smig.perform_commands(theCommands)\n tempFile = File.join(Dir.tmpdir(), baseImageName)\n origFile = File.join($compareImageDir, baseImageName)\n unless AreImageFilesSame(origFile, tempFile, 3)\n # 10. Report if different.\n raise \"Different image files: \" + origFile + \" and \" + tempFile\n end\n rescue RuntimeError => e\n $errorcode = Smig.exitvalue\n unless $errorcode.zero?\n puts \"Exit string: \" + Smig.exitstring\n puts \"Exit status: \" + $errorcode.to_s\n end\n puts e.message\n puts e.backtrace.to_s\n# exit 240\n ensure\n FileUtils.rm_f(tempFile) unless tempFile.nil?\n end\nend",
"def context\n unless @instance_context\n @instance_context = CompositionHookContext.new(@version, @params['sid'], )\n end\n @instance_context\n end",
"def info_graphics(*args)\n @p.info_graphics(self, *args)\n end",
"def display_exp_and_gold\n # Does nothing, will be managed in Scene_Victory\n end",
"def display_exp_and_gold\n # Does nothing, will be managed in Scene_Victory\n end",
"def special_usage\n puts \"Available Options for Specialty Tools Menu: \".underline.white\n puts \"back \".light_yellow + \" => \".white + \"Return to Main Menu\".light_red\n puts \"coldfusion\".light_yellow + \" => \".white + \"Coldfusion Tools\".light_red\n puts \"moinmoin\".light_yellow + \" => \".white + \"MoinMoin RCE\".light_red\n puts \"phpcgi\".light_yellow + \" => \".white + \"PHP CGI RCE Tools\".light_red\n puts \"phpBB\".light_yellow + \" => \".white + \"phpBB Tools\".light_red\n puts \"ipb\".light_yellow + \" => \".white + \"IPB Tools\".light_red\n# puts \"joomla\".light_yellow + \" => \".white + \"Joomla! Tools\".light_red\n# puts \"myBB\".light_yellow + \" => \".white + \"MyBB Tools\".light_red\n# puts \"vBulletin\".light_yellow + \" => \".white + \"vBulletin Tools\".light_red\n puts \"wp\".light_yellow + \" => \".white + \"WordPress Tools\".light_red\n puts \"fckeditor\".light_yellow + \" => \".white + \"FCKEditor Tools\".light_red\n print_line(\"\")\nend",
"def graphic(&block)\n psfc=RGhost::PsFacade.new\n yield psfc\n raw :gsave\n set psfc\n raw :grestore\n\n end",
"def append_features(mod) end",
"def list_features *args\r\n puts \"not implemented yet\"\r\n end",
"def description ()\n return context.description \n end",
"def enable_advanced_debugging_tools=(_arg0); end",
"def context\n unless @instance_context\n @instance_context = InteractionContext.new(@version , @params['sid'])\n end\n @instance_context\n end",
"def texify exec_trace\n document_text = \"\"\n File.open \"preamble.tex\" do |file|\n while line = file.gets\n document_text += line\n end\n end\n document_text += \"\\\\begin{document}\\n\"\n stages = get_stages exec_trace\n stages.each do |stage|\n document_text += \"\\\\begin{frame}\\n\\n\"\n document_text += state_text stage.i_heap, stage.i_store\n document_text += \"\\n\"\n document_text += \"Current command: \"\n document_text += \"\\\\il{#{stage.text}}\"\n document_text += \"\\n\"\n document_text += \"\\\\vspace{1cm}\\n\\n\"\n document_text += state_text stage.f_heap, stage.f_store\n document_text += \"\\\\end{frame}\"\n document_text += \"\\n\"\n end\n document_text\nend",
"def gp_flags; end",
"def append_features(context) # :nodoc:\n context.class_eval do\n context_methods = context.instance_methods(false)\n Helpers.public_instance_methods.each do |method|\n remove_method(method) if context_methods.include?(method)\n end\n end\n\n super(context)\n end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context=(_arg0); end",
"def context\n unless @instance_context\n @instance_context = CpsContext.new(@version, )\n end\n @instance_context\n end",
"def edit_object(obj)\r\n puts \"edit object #{obj}\" if VERBOSE\r\n Sketchup.active_model.select_tool EditOpeningTool.new(self, obj)\r\nend",
"def feature_args(ci_gcc_config)\n return [] if ci_gcc_config[:features].nil?\n\n ci_gcc_config[:features].map { |f| \"-f#{f}\" }\n end",
"def in_context(context); end",
"def main\n # force close gedit process if open\n system('killall', 'gedit')\n \n # ***** uncomment the line below to install soothing fonts *****\n # system('sudo apt-get install ttf-bitstream-vera ttf-dejavu ttf-dejavu ttf-dejavu-core ttf-dejavu-extra ttf-liberation')\n \n # copy mime files\n FileUtils.cp_r('mime/.','usr/share/mime/packages')\n FileUtils.chmod_R(0644, '/usr/share/mime/packages/*.xml')\n system('update-mime-database', '/usr/share/mime')\n \n # copy language files\n print \"copying language files...\"\n FileUtils.cp_r('languages/.', '/usr/share/gtksourceview-2.0/language-specs/')\n system('sudo chmod 644', '/usr/share/gtksourceview-2.0/language-specs/*.lang')\n print \"done.\\n\"\n \n # copy theme files\n print \"copying theme files...\"\n FileUtils.cp_r('themes/.', '/usr/share/gtksourceview-2.0/styles')\n system('sudo chmod 644', '/usr/share/gtksourceview-2.0/styles/*.xml')\n print \"done.\\n\"\n \n # specify folders \n gedit_dir = \"#{ENV['HOME']}/.gnome2/gedit\"\n snippets_dir = \"#{gedit_dir}/snippets\"\n plugins_dir = \"#{gedit_dir}/plugins\"\n\n # create necessary folders for plugins and snippets if they don't exists\n FileUtils.mkdir_p(snippets_dir) unless File.directory?(snippets_dir)\n FileUtils.mkdir_p(plugins_dir) unless File.directory?(plugins_dir)\n \n # copy snippets and plugins\n print \"copying snippets and plugins...\"\n FileUtils.cp_r('snippets/.', snippets_dir)\n FileUtils.cp_r('plugins/.', plugins_dir)\n print \"done.\\n\"\n \n # give proper permissions to these files (otherwise gedit wont read them)\n system('sudo -R chmod 644', snippets_dir)\n system('sudo -R chmod +x', plugins_dir)\n \n puts \"power-gedit setup complete - enjoy!\"\n \nend",
"def update\n super\n @description_window.print_description(@commande_list_window.index)\n if @window_command_command_face_define\n id = @window_command_command_face_define.index\n @window_command_face_view.name = @array_face[id]\n @window_command_face_view.draw_item\n end\n if @window_command_variable\n @window_command_variable_description.print_description(@window_command_variable.index)\n end\n end",
"def devtools_identifier=(_arg0); end",
"def regenerate_context\n spec_hash = { :extraConfig => extraconfig_context }\n spec = RbVmomi::VIM.VirtualMachineConfigSpec(spec_hash)\n\n begin\n @item.ReconfigVM_Task(:spec => spec).wait_for_completion\n rescue StandardError => e\n error = \"Cannot generate VM context info: #{e.message}.\"\n\n if VCenterDriver::CONFIG[:debug_information]\n error += \"\\n\\n#{e.backtrace}\"\n end\n\n raise error\n end\n end",
"def context\n unless @instance_context\n @instance_context = FeedbackSummaryContext.new(@version , @params['account_sid'], @params['sid'])\n end\n @instance_context\n end",
"def update_fusion\n end",
"def frame_managers(_pry_); end",
"def update!(**args)\n @enhanced_image = args[:enhanced_image] if args.key?(:enhanced_image)\n @feature_graphic = args[:feature_graphic] if args.key?(:feature_graphic)\n @screenshot = args[:screenshot] if args.key?(:screenshot)\n end",
"def last_context; end",
"def main\n dict={}\n c=0; p=0\n gtf=gtfread(GTFPATH)\n Dir.glob(DIRECTORY+\"/**/*.pre\").each do |path|\n dict[path.split('/')[-1].split('.')[0]]=process(path, gtf)\n end\n genes,c,p=significant(gtf)\n dc=(C/c).floor\n dp=(P/p).floor\n Dir.glob(DIRECTORY+\"/**/*.pre\").each do |path|\n printer(path.split('.')[0]+\".fc\",dict[path.split('/')[-1].split('.')[0]],gtf,dc,dp,genes,\"foldchange\")\n printer(path.split('.')[0]+\".pval\",dict[path.split('/')[-1].split('.')[0]],gtf,dc,dp,genes,\"pval\")\n end\n bashcommands\nend",
"def summary_img\n num_tracks_needed = 1\n\n begin\n p = Bio::Graphics::Page.new(:width => 962, :height => 150, :number_of_intervals => 10)\n\n #separate features into mRNA or gene features\n\n genes = @features.select { |x| x.feature == 'gene' }\n if not genes.empty?\n gene_track = p.add_track(:glyph => :directed,\n :fill_color => :green_white_radial,\n :label => false\n )\n # mrna_track = p.add_track(:glyph => :transcript,\n # :exon_fill_color => :red_white_h,\n # :utr_fill_color => :blue_white_h\n # )\ngenes.each do |gene|\n feat = Bio::Graphics::MiniFeature.new(:start => gene.start,\n :end => gene.end,\n :strand => gene.strand,\n :id => gene.gff_id)\n gene_track.add(feat)\nend\nend\n\nproteins = @features.select { |x| x.feature == 'protein' }\n\nif not proteins.empty?\n protein_track = p.add_track(\n :glyph => :generic,\n :fill_color => :yellow_white_radial,\n :label => false\n )\n proteins.each do |protein|\n feat = Bio::Graphics::MiniFeature.new(:start => protein.start,\n :end => protein.end,\n :id => protein.gff_id\n )\n protein_track.add(feat)\n end\nend\n\n\nmrnas = @features.select { |x| x.feature == 'mRNA' }\n@mrnas = mrnas\nif not mrnas.empty?\n mrna_track = p.add_track(:glyph => :transcript,\n :exon_fill_color => :red_white_h,\n :utr_fill_color => :blue_white_h,\n :label => false,\n :gap_marker => 'angled'\n )\n mrnas.each do |m|\n exons = []\n utrs = []\n m.children.each do |d|\n if d.feature == 'exon'\n exons << d.start\n exons << d.end\n end\n if d.feature == 'five_prime_UTR' or d.feature == 'three_prime_UTR'\n utrs << d.start\n utrs << d.end\n end\n exons.sort!\n utrs.sort!\n end\n @exons = exons\n @utrs = utrs\n\n if exons.empty?\n exons = [m.start, m.end]\n end\n\n if utrs.empty?\n utrs = [m.start, m.end]\n end\n feat = Bio::Graphics::MiniFeature.new(\n :start => m.start,\n :end => m.end,\n :strand => m.strand,\n :exons => exons,\n :utrs => utrs,\n :id => m.gff_id\n )\n mrna_track.add(feat)\n end\nend\n@svg = p.get_markup\nrescue\n @svg = \"\"\nend\n\nend",
"def display_version\n @colour.help FORGEN_VERSION_NUMBER\nend",
"def display_data_universe\n\n end",
"def modifyContext\n\n begin\n\n # @context_owner = params[:username] ? User.find_by_username(params[:username]) : nil\n # @context = @context_owner ? @context_owner.contexts.find(:first, :conditions => ['name = ?', params[:contextname]]) : nil\n # if not @context_owner or not @context\n # render :text => \"Context: #{params[:contextname]} not found! \\n\", :status => 404\n # return\n # end\n \n if params[:contexthash] && params[:contexthash] != nil\n \n @context = Context.find_by_context_hash(params[:contexthash])\n\n elsif params[:username] && params[:contextname] && params[:username] != nil && params[:contextname] != nil\n\n ctx_name = ContextName.find_by_username_and_name(params[:username].downcase, params[:contextname].downcase)\n if ctx_name == nil\n render :text => \"Context:not found! \\n\", :status => 404\n return\n end\n \n @context_id = ctx_name.context_id\n \n # Get context with context_hash\n @context = Context.find_by_id(@context_id)\n \n else\n render :text => \"Context: not found! \\n\", :status => 404\n return\n \n end\n \n if @context == nil\n render :text => \"Context: not found! \\n\", :status => 404\n return\n end\n\n @context_id = @context.id\n\n # user-object who is signed in, if not signed in has nil\n @user = whoIsSignedIn\n\n # Checks that user is authorized to modify context\n if not authorizedToContext(@context.context_hash)\n render :text => \"Not authorized to modify this context\", :status => 409\n return\n end\n \n \n \n # If uri for file is given -> adds file to context\n if params[:file_uri]\n addFileToContext(@context)\n puts \"file was added to context!\"\n end\n \n # Modifying other stuff \n modifyContextInformations\n \n\n rescue Exception => ex\n putsE(ex)\n render :text => \"Error in modifying context! \\n\", :status => 409\n return\n end\n\n\n render :text => \"Context: #{params[:contextname]} modified successfully! \\n\", :status => 200\n return\n end",
"def execute(_type)\n puts \"Features packaged: #{List.features}\" if List.cli.data[:verbose]\n list(List.features)\n end",
"def help\n puts `setxkbmap -print -verbose 10`\nend",
"def lookup_context=(_arg0); end",
"def arguments(workspace)\n args = OpenStudio::Ruleset::OSArgumentVector.new\n\n glzsys = OpenStudio::StringVector.new\n glzsys << \"Single_Pane\"\n glzsys << \"Double_Pane\"\n glzsys << \"Triple_Pane\"\n glzsys << \"VIG\"\n glzsys << \"ASHRAE_Detailed\"\n glzsys << \"Static\"\n glzsys << \"SwitchGlaze\"\n \n glztype = OpenStudio::Ruleset::OSArgument::makeChoiceArgument('glztype', glzsys, true)\n glztype.setDisplayName(\"Choice of IGU\")\n glztype.setDefaultValue(\"SwitchGlaze\")\n args << glztype\n \n #make choice arguments for fenestration surface\n fenestrationsurfaces = workspace.getObjectsByType(\"FenestrationSurface:Detailed\".to_IddObjectType)\n chs = OpenStudio::StringVector.new\n fenestrationsurfaces.each do |fenestrationsurface|\n chs << fenestrationsurface.name.to_s\n end\n chs << $allchoices\n chs << \"inferred\"\n choice = OpenStudio::Ruleset::OSArgument::makeChoiceArgument('choice', chs, true)\n choice.setDisplayName(\"Choice of window\")\n choice.setDefaultValue($allchoices)\n args << choice\n \n # path to the folder that includes idf files containing window objects\n idf_path = OpenStudio::Ruleset::OSArgument.makeStringArgument(\"idf_path\", true)\n idf_path.setDisplayName(\"path to the folder that includes idf files containing window objects\")\n idf_path.setDefaultValue('C:\\SpectralIDFs')\n args << idf_path\n \n # thermochromic window switching temperature\n t_switching = OpenStudio::Ruleset::OSArgument.makeDoubleArgument(\"t_switching\", true)\n t_switching.setDisplayName(\"Switching temperature of a thermochromic window\")\n t_switching.setDescription('Only applicable when thermochromic window is selected')\n t_switching.setUnits(\"C\")\n t_switching.setDefaultValue(35)\n args << t_switching\n \n # \n serverrun = OpenStudio::Ruleset::OSArgument::makeBoolArgument('serverrun', false)\n serverrun.setDisplayName('Running on the server (and not in local)?')\n serverrun.setDefaultValue('false')\n serverrun.setDescription('Select if simulation is being ran on the server')\n args << serverrun\n\n return args\n end"
] |
[
"0.58085936",
"0.5470395",
"0.54541117",
"0.5428322",
"0.5416372",
"0.53946114",
"0.5382076",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53657544",
"0.53565186",
"0.5352029",
"0.53401583",
"0.5317577",
"0.53161323",
"0.52503926",
"0.5241276",
"0.51951325",
"0.51943517",
"0.5186121",
"0.5184983",
"0.51574844",
"0.50950974",
"0.5083478",
"0.50833225",
"0.50820684",
"0.50588095",
"0.50548595",
"0.50508016",
"0.5048849",
"0.5048849",
"0.5048849",
"0.501893",
"0.50181264",
"0.5016358",
"0.5011155",
"0.49931505",
"0.49627256",
"0.49627256",
"0.4959729",
"0.49564913",
"0.49560735",
"0.4949971",
"0.49327904",
"0.49024662",
"0.4901608",
"0.49000564",
"0.48919442",
"0.48885435",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.48827696",
"0.487925",
"0.48727146",
"0.48709476",
"0.4864681",
"0.4863325",
"0.4861065",
"0.4857997",
"0.48564035",
"0.48535165",
"0.48484564",
"0.4843574",
"0.4836877",
"0.4835795",
"0.48252144",
"0.4822517",
"0.48134333",
"0.47959065",
"0.47903854",
"0.47754902",
"0.47749403",
"0.47738564",
"0.4773586"
] |
0.64635056
|
0
|
context_get_bgcolor: retrieves the current background color. This returns an integer, not an object
|
def context_get_bgcolor()
return $gimp_iface.gimp_context_get_background()[0]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def background_color\n return @background_color\n end",
"def bgcolor\n @bgcolor || $def_bg_color\n end",
"def bgColor\n return @bg_color\n end",
"def background_colour\n @cr[0xf] >> 4\n end",
"def background_color\n return @peer.background_color\n end",
"def background_color(color); end",
"def background_color\n @background_color ||= [0, 0, 0]\n end",
"def background(bgcolor)\n names_to_code(\"on_\" + bgcolor)\n end",
"def background_color(color)\n self.class.color_codes[color] + 40 if self.class.color_codes[color]\n end",
"def background_color(color)\n self.class.color_codes[color] + 40 if self.class.color_codes[color]\n end",
"def bgcolor( *val )\n if val.empty?\n return @bgcolor if @bgcolor\n return @form.bgcolor if @form\n return $def_bg_color\n else\n @color_pair = nil\n return property_set :bgcolor, val\n end\n end",
"def background_color\n ::Color::RGB.from_applescript(advanced_typing_apparatus.background_color).html\n end",
"def receipt_bgcolor\n get_attribute(Yoti::Attribute::APPLICATION_RECEIPT_BGCOLOR)\n end",
"def context_get_fgcolor()\n return $gimp_iface.gimp_context_get_foreground()[0]\nend",
"def background_color=(value)\n @background_color = value\n end",
"def backgroundcolor\n colors = {\n \"#E50914\" => \"#282581\", \"#FF0000\" => \"#0A0D44\", \"#00FF8F\" => \"#0A00A4\", \"#FFF300\" => \"#E80000\", \"#00E8C5\" => \"#5A009C\", \"#FF9E00\" => \"#5A009C\", \"#FFEC00\" => \"#FF00A6\", \"#51FF00\" => \"#7400BF\"}\n color1, color2 = colors.to_a.sample\n session[:color1] = color1\n session[:color2] = color2\n end",
"def Pager_GetBkColor(hwnd) send_pager_message(hwnd, :GETBKCOLOR) end",
"def _context_set_bgcolor!(rgb)\n $gimp_iface.gimp_context_set_background(rgb)\nend",
"def event_bg_color\n @i ||= -1\n COLORS[(@i += 1) % COLORS.size]\n end",
"def backgroundColor\n if self.highest?\n \"#ff884d\"\n elsif self.high?\n \"#ffcc80\"\n else\n \"#ffefcc\"\n end\n end",
"def background_color=(value)\n @peer.background_color = value.to_s\n end",
"def background_fill\n @background_fill ||= begin\n digest = \"0.#{Digest::MD5.hexdigest(@name).to_i(16).to_s}\".to_f\n index = (digest * (@background_colors.length - 1)).round\n @background_colors[index]\n end\n end",
"def get_color\n @color\n end",
"def open_background_color_span\n \"<span style=\\\"background-color:##{self.html_color};\\\">\"\n end",
"def bg_properties \n color_properties.select {|key, value| key.include?(\"background\") }\n end",
"def backgroundColor\n self.layer.backgroundColor\n end",
"def background\n return @background if defined?(@background)\n @background = true\n end",
"def backgroundColor(theColor, target = nil)\n return if theColor.nil?\n if target == 'window'\n @alert.window.backgroundColor = MEalert.getColor(theColor, 'windowBackground')\n else # set the color name for the accessory textField\n @coloration[:background] = theColor\n end\n end",
"def bgcolor!\n # -> uncomment the next line to manually enable rule tracing\n # trace_in( __method__, 30 )\n\n type = BGCOLOR\n channel = ANTLR3::DEFAULT_CHANNEL\n\n \n # - - - - main rule block - - - -\n # at line 360:10: 'bgcolor'\n match( \"bgcolor\" )\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__, 30 )\n\n end",
"def primary_button_background_color\n block_for('primary_button_background_color', '#286090')\n end",
"def color\n @color || $def_fg_color\n end",
"def primary_button_active_background_color\n darken_color(primary_button_background_color, 0.1)\n end",
"def color_id\n object.calendar.get_color(user_context.id)\n end",
"def color\n return @color\n end",
"def color\n return @color\n end",
"def ListView_GetBkColor(hwnd) send_listview_message(hwnd, :GETBKCOLOR) end",
"def content_colors fg, bg\n @color = fg\n @bgcolor = bg\n @color_pair = get_color($datacolor, fg, bg)\n end",
"def color\n @color ||= color_scope.first\n end",
"def foreground_fill\n red = background_fill[1..2].to_i(16)\n green = background_fill[3..4].to_i(16)\n blue = background_fill[5..6].to_i(16)\n (red * 0.299 + green * 0.587 + blue * 0.114) > 186 ? '#000000' : '#FFFFFF'\n end",
"def get_topic_bg_color(topic)\n rgb = 'rgb(' + (400*(1-(Math.tanh(2*[@max_team_size.to_f/Bid.where(topic_id:topic.id).count,1].min-1)+1)/2))\n .to_i.to_s + ',' + (400*(Math.tanh(2*[@max_team_size.to_f/Bid.where(topic_id:topic.id).\n count,1].min-1)+1)/2).to_i.to_s + ',0)'\n puts rgb\n rgb\n end",
"def color\n return @color\n end",
"def textbackground(color = nil)\n if color\n @text.background(color)\n else\n @text.background\n end\n end",
"def default_color\n return current_layout.default_color\n end",
"def color\n\t\treturn @color\n\t\t\n\tend",
"def isDarkBackground(background,rect=nil)\n return true if !background || background.disposed?\n rect=background.rect if !rect\n return true if rect.width<=0 || rect.height<=0\n xSeg=(rect.width/16)\n xLoop=(xSeg==0) ? 1 : 16\n xStart=(xSeg==0) ? rect.x+(rect.width/2) : rect.x+xSeg/2\n ySeg=(rect.height/16)\n yLoop=(ySeg==0) ? 1 : 16\n yStart=(ySeg==0) ? rect.y+(rect.height/2) : rect.y+ySeg/2\n count=0\n y=yStart\n r=0; g=0; b=0\n yLoop.times {\n x=xStart\n xLoop.times {\n clr=background.get_pixel(x,y)\n if clr.alpha!=0\n r+=clr.red; g+=clr.green; b+=clr.blue\n count+=1\n end\n x+=xSeg\n }\n y+=ySeg\n }\n return true if count==0\n r/=count\n g/=count\n b/=count\n return (r*0.299+g*0.587+b*0.114)<128\nend",
"def color_to_use\n return :no_bg_color if value == :none\n value =~ /^on_/ ? value : \"on_#{value}\".to_sym\n end",
"def bg_color=(v)\n DataTypeValidator.validate(:color, Color, Color.new(rgb: v))\n @bg_color = v\n end",
"def background(color=nil)\n @options[:background] = color unless color.nil?\n @options[:background]\n end",
"def get_color\n if @thread\n return CYCLING\n end\n\n pins = COLORS.select do |pin|\n get_pin pin\n end\n\n if pins.length == 0\n return nil\n elsif pins.length == 1\n return pins.first\n else\n return INVALID_STATE\n end\n end",
"def rgb(red, green, blue, background = false)\n \"#{background ? 48 : 38}#{rgb_value(red, green, blue)}\"\n end",
"def rgb(red, green, blue, background = false)\n \"#{background ? 48 : 38};5;#{rgb_value(red, green, blue)}\"\n end",
"def background(marked_tag, highlight_related_tags: true)\n return '#f00' if self == marked_tag\n return '#ff8c00' if highlight_related_tags && in?(marked_tag.related_tags)\n '#666'\n end",
"def getDrawColor()\n return @drawColor\n end",
"def _color\n\t\tcolor = Color.where(:inki_model_name => self.class.to_s, :model_id => self.id).first\n\t\tif color\n\t\t\tcolor.rgb_id\n\t\tend\n\tend",
"def primary_button_focus_background_color\n darken_color(primary_button_background_color, 0.1)\n end",
"def footer_background_color_css_val\n \"background-color: \" + shop.footer_background_color\n end",
"def rgb(red, green, blue, background = false)\n case @mode\n when 8\n \"#{background ? 4 : 3}#{rgb_to_ansi(red, green, blue, false)}\"\n when 16\n \"#{background ? 4 : 3}#{rgb_to_ansi(red, green, blue, true)}\"\n when 256\n \"#{background ? 48 : 38}#{rgb_to_256(red, green, blue)}\"\n when TRUE_COLOR\n \"#{background ? 48 : 38}#{rgb_true(red, green, blue)}\"\n end\n end",
"def background(r=1, g=1, b=1, a=1.0)\n case r\n when Color\n g = r.g\n b = r.b\n a = r.a\n r = r.r\n end\n push\n CGContextSetRGBFillColor(@ctx, r, g, b, a) # RGBA\n rect(0,0,@width,@height)\n pop\n end",
"def back_color1\n Color.new(0, 0, 0, 192)\n end",
"def back_color1\n Color.new(0, 0, 0, 192)\n end",
"def get_color default=$datacolor, color=color(), bgcolor=bgcolor()\n return default if color.nil? || bgcolor.nil?\n #raise ArgumentError, \"Color not valid: #{color}: #{ColorMap.colors} \" if !ColorMap.is_color? color\n #raise ArgumentError, \"Bgolor not valid: #{bgcolor} : #{ColorMap.colors} \" if !ColorMap.is_color? bgcolor\n acolor = ColorMap.get_color(color, bgcolor)\n return acolor\n end",
"def rgb(red, green, blue, background = false)\n if mode == 8 || mode == 16\n \"#{background ? 4 : 3}#{rgb_like_value(red, green, blue, mode == 16)}\"\n else\n \"#{background ? 48 : 38}#{rgb_value(red, green, blue)}\"\n end\n end",
"def draw_background\n\t\tcolor = self.colour_scheme.background\t\n\t\t@canvas.new_image(@canvas_width, @canvas_height) { self.background_color = color }\n\tend",
"def hex_color\n return @hex_color\n end",
"def back_color1\n Color.new(0, 0, 0, 192)\n end",
"def header_background_color\n block_for('header_background_color', '#3c3c3c')\n end",
"def TreeView_GetBkColor(hwnd) send_treeview_message(hwnd, :GETBKCOLOR) end",
"def fcolor(bgcolor = \"#000\", light = \"#fff\", dark = \"#000\")\n bg = bgcolor.gsub(/[^0-9a-f]/i, \"\")\n # convert 3 char to 6 char hex\n bg.gsub!(/./, '\\&\\&') if bg.length == 3\n sum = 0\n [0, 2, 4].each do |i|\n sum += bg[i..i+1].to_i(16)\n end\n return (sum/3 < 128) ? light : dark\n end",
"def context_get_brush()\n return $gimp_iface.gimp_context_get_brush()[0]\nend",
"def color\n @color\n end",
"def color\n @color\n end",
"def color_top\n @attributes[:color_top]\n end",
"def parent_color\n return self.element.color if self.element\n return self.group.color if self.group\n end",
"def green\n colorize(32)\n end",
"def setBackGround(o)\n if useHighLightOnCurrentElement\n begin \n @currentObjectBackGroundColor = o.style.backgroundColor\n #puts \"Current Back ground color is: #{@currentObjectBackGroundColor}\"\n @backGroundObject = o\n @backGroundObject.style.backgroundColor = \"red\"\n rescue\n\n end\n end\n end",
"def switch_background(color)\n color == [248,250,210] ? [215,188,149] : [248,250,210]\n end",
"def green\n (rgba & 0x00FF00) >> 8\n end",
"def getColor(theColor, default = 'gray')\n preset = Proc.new do |color|\n case color\n when 'windowBackground' then return NSColor.windowBackgroundColor # 0.93\n when 'textColor' then return NSColor.textColor # 0.0\n when 'backgroundColor' then return NSColor.textBackgroundColor # 1.0\n when 'clear' then return NSColor.clearColor\n else color\n end\n end\n if preset.call(theColor) == 'box' # box fill color doesn't have a system color\n dark = !NSAppearance.currentAppearance.name.to_s.index('Dark').nil?\n rgb = dark ? [0.12, 0.12, 0.12] : [0.89, 0.89, 0.89]\n else # get the specified color or default - no dark mode swaps are performed\n rgb = COLORS[preset.call(default)] if (rgb = COLORS[theColor]).nil?\n end\n rgb = [0.5, 0.5, 0.5] if rgb.nil? # get gray if nothing else has worked\n NSColor.colorWithSRGBRed( rgb[0],\n green: rgb[1],\n blue: rgb[2],\n alpha: 1.0 )\n end",
"def textColor\n return @text_color\n end",
"def background=(value)\n @background = Vedeu::Colours::Background.coerce(value)\n end",
"def background?\n @background\n end",
"def default_color\n return translate_color(current_layout.default_color)\n end",
"def color\n @color;\n end",
"def color\n @attributes[:color]\n end",
"def color\n @data[:color]\n end",
"def back_color2\n Color.new(0, 0, 0, 0)\n end",
"def back_color2\n Color.new(0, 0, 0, 0)\n end",
"def green\n ((hex_color & GREEN) >> 8) / MAX_RGB_VALUE * 100\n end",
"def ayty_background_list_responsible_for_style(issue, issue_id_play)\n if issue.id.to_s == issue_id_play.to_s\n return \"background: #5CACEE\"\n end\n status_id = issue.status_id.to_i\n return case status_id\n when 8,31\n \"background: #A0A0A0\"\n when 9,11\n \"background: #FF9664\"\n when 25,14\n \"background: #00C864\"\n when 22,23\n \"background: #FA5050\"\n when 34,13\n \"background: #C8FFC8\"\n when 32\n \"background: #C878C8\"\n when 15,16,17\n \"background: #508250\"\n else\n \"\"\n end\n end",
"def fill_color()\n validate_worksheet\n xf = @workbook.get_style_attributes(@workbook.get_style(@style_index))\n return @workbook.get_fill_color(xf)\n end",
"def hex_color\n self.color_hex\n end",
"def setBackground\r\n r = g = b = a = 0.0\r\n case $background\r\n when 0\r\n r = g = b = 0.0\r\n when 1\r\n r = g = b = 1.0\r\n when 2\r\n r = 0.1\r\n g = 0.3\r\n b = 0.6\r\n when 3\r\n r = g = b = 0.5\r\n else\r\n r = g = b = 0.0\r\n end\r\n a = 1.0\r\n glClearColor(r,g,b,a)\r\nend",
"def color_id\n return nil unless colored?\n\n Tapyrus::Color::ColorIdentifier.parse_from_payload(chunks[0].pushed_data)\n end",
"def green\n\t\tlight COLOR_KEY_GREEN\n\tend",
"def state_color\n result = nil\n states.each do |state|\n result = state.color if state.color\n end\n return result || EmptyColor\n end",
"def fg(c)\n return self unless ANSI_COLORS[c]\n return colorize(ANSI_COLORS[c])\n end",
"def status_style(checker)\n \"background-color: #{checker.status.nil? ? :green : :red}\"\n end",
"def bg_red; use_code(41) end",
"def gauge_back_color\n return Color.new(120,120,120)\n end",
"def bg_color_methods\n color_methods.collect do |color|\n \"bg_#{color}\".to_sym\n end\n end"
] |
[
"0.75258",
"0.74347776",
"0.741705",
"0.7208971",
"0.7142372",
"0.696189",
"0.6879816",
"0.6850754",
"0.6720105",
"0.6720105",
"0.6632355",
"0.6425548",
"0.64068097",
"0.6327581",
"0.6295605",
"0.62035584",
"0.6187676",
"0.6130814",
"0.61186284",
"0.60704035",
"0.5986553",
"0.5918794",
"0.58668107",
"0.58044934",
"0.58014786",
"0.57875574",
"0.57692164",
"0.5766627",
"0.57039577",
"0.568206",
"0.56820136",
"0.56763846",
"0.56755537",
"0.5660249",
"0.5660249",
"0.5639619",
"0.5624032",
"0.5620977",
"0.56140095",
"0.56119955",
"0.5593058",
"0.55874175",
"0.55833495",
"0.5561787",
"0.5553201",
"0.55452776",
"0.5543137",
"0.5540924",
"0.55263484",
"0.5504204",
"0.54942745",
"0.5492658",
"0.5467081",
"0.54343724",
"0.53912276",
"0.53751564",
"0.5366384",
"0.53340447",
"0.5325087",
"0.5325087",
"0.53230864",
"0.53218657",
"0.532111",
"0.53082323",
"0.5291335",
"0.52544653",
"0.52542925",
"0.52377266",
"0.5234175",
"0.52338874",
"0.52338874",
"0.5231638",
"0.5227502",
"0.52225304",
"0.521979",
"0.5199634",
"0.5177303",
"0.51613855",
"0.5158128",
"0.51554334",
"0.514814",
"0.5142881",
"0.51327366",
"0.5128187",
"0.51159334",
"0.51150185",
"0.51150185",
"0.5091892",
"0.50911015",
"0.5088422",
"0.5087608",
"0.5081667",
"0.5071656",
"0.50614697",
"0.5052125",
"0.5044379",
"0.50433683",
"0.5038877",
"0.50360054",
"0.5036005"
] |
0.78690106
|
0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.