_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q25700 | SourceRoute.TraceFilter.block_it? | validation | def block_it?(tp)
if @cond.track_params
return true if negative_check(tp)
if positives_check(tp)
return !tp.binding.eval('local_variables').any? do |v|
tp.binding.local_variable_get(v).object_id == @cond.track_params
end
end
else
return true if negative_check(tp)
return false if positives_check(tp)
end
true # default is blocked the tp
end | ruby | {
"resource": ""
} |
q25701 | OnedClusterer.Clusterer.classify | validation | def classify(value)
raise ArgumentError, "value: #{value} must be in data array" unless @data.include?(value)
bounds[1..-1].index { |bound| value <= bound }
end | ruby | {
"resource": ""
} |
q25702 | OnedClusterer.Clusterer.intervals | validation | def intervals
first, *rest = bounds.each_cons(2).to_a
[first, *rest.map {|lower, upper| [data[data.rindex(lower) + 1] , upper] }]
end | ruby | {
"resource": ""
} |
q25703 | OnedClusterer.Jenks.matrices | validation | def matrices
rows = data.size
cols = n_classes
# in the original implementation, these matrices are referred to
# as `LC` and `OP`
# * lower_class_limits (LC): optimal lower class limits
# * variance_combinations (OP): optimal variance combinations for all classes
lower_class_limits = *Matrix.zero(rows + 1, cols + 1)
variance_combinations = *Matrix.zero(rows + 1, cols + 1)
# the variance, as computed at each step in the calculation
variance = 0
for i in 1..cols
lower_class_limits[1][i] = 1
variance_combinations[1][i] = 0
for j in 2..rows
variance_combinations[j][i] = Float::INFINITY
end
end
for l in 2..rows
sum = 0 # `SZ` originally. this is the sum of the values seen thus far when calculating variance.
sum_squares = 0 # `ZSQ` originally. the sum of squares of values seen thus far
w = 0 # `WT` originally. This is the number of data points considered so far.
for m in 1..l
lower_class_limit = l - m + 1 # `III` originally
val = data[lower_class_limit - 1]
# here we're estimating variance for each potential classing
# of the data, for each potential number of classes. `w`
# is the number of data points considered so far.
w += 1
# increase the current sum and sum-of-squares
sum += val
sum_squares += (val ** 2)
# the variance at this point in the sequence is the difference
# between the sum of squares and the total x 2, over the number
# of samples.
variance = sum_squares - (sum ** 2) / w
i4 = lower_class_limit - 1 # `IV` originally
if i4 != 0
for j in 2..cols
# if adding this element to an existing class
# will increase its variance beyond the limit, break
# the class at this point, setting the lower_class_limit
# at this point.
if variance_combinations[l][j] >= (variance + variance_combinations[i4][j - 1])
lower_class_limits[l][j] = lower_class_limit
variance_combinations[l][j] = variance +
variance_combinations[i4][j - 1]
end
end
end
end
lower_class_limits[l][1] = 1
variance_combinations[l][1] = variance
end
[lower_class_limits, variance_combinations]
end | ruby | {
"resource": ""
} |
q25704 | Omdb.Api.fetch | validation | def fetch(title, year = "", tomatoes = false, plot = "short")
res = network.call({ t: title, y: year, tomatoes: tomatoes, plot: plot })
if res[:data]["Response"] == "False"
{ status: 404 }
else
{ status: res[:code], movie: parse_movie(res[:data]) }
end
end | ruby | {
"resource": ""
} |
q25705 | Omdb.Api.find | validation | def find(id, tomatoes = false, plot = "short")
res = network.call({ i: id, tomatoes: tomatoes, plot: plot })
if res[:data]["Response"] == "False"
{ status: 404 }
else
{ status: res[:code], movie: parse_movie(res[:data]) }
end
end | ruby | {
"resource": ""
} |
q25706 | G5AuthenticationClient.Configuration.options | validation | def options
VALID_CONFIG_OPTIONS.inject({}) do |option, key|
option.merge!(key => send(key))
end
end | ruby | {
"resource": ""
} |
q25707 | G5AuthenticationClient.Client.create_user | validation | def create_user(options={})
user=User.new(options)
user.validate_for_create!
body = user_hash(user.to_hash)
response=oauth_access_token.post('/v1/users', body: body)
User.new(response.parsed)
end | ruby | {
"resource": ""
} |
q25708 | G5AuthenticationClient.Client.update_user | validation | def update_user(options={})
user=User.new(options)
user.validate!
response=oauth_access_token.put("/v1/users/#{user.id}", body: user_hash(user.to_hash))
User.new(response.parsed)
end | ruby | {
"resource": ""
} |
q25709 | G5AuthenticationClient.Client.find_user_by_email | validation | def find_user_by_email(email)
response = oauth_access_token.get('/v1/users', params: { email: email })
user = response.parsed.first
if user
user=User.new(user)
end
user
end | ruby | {
"resource": ""
} |
q25710 | G5AuthenticationClient.Client.sign_out_url | validation | def sign_out_url(redirect_url=nil)
auth_server_url = Addressable::URI.parse(endpoint)
auth_server_url.path = '/users/sign_out'
auth_server_url.query_values = {redirect_url: redirect_url} if redirect_url
auth_server_url.to_s
end | ruby | {
"resource": ""
} |
q25711 | G5AuthenticationClient.Client.list_users | validation | def list_users
response=oauth_access_token.get("/v1/users")
response.parsed.collect { |parsed_user| User.new(parsed_user) }
end | ruby | {
"resource": ""
} |
q25712 | G5AuthenticationClient.Client.list_roles | validation | def list_roles
response = oauth_access_token.get('/v1/roles')
response.parsed.collect { |parsed_role| Role.new(parsed_role) }
end | ruby | {
"resource": ""
} |
q25713 | CloudApp.Client.bookmark | validation | def bookmark(*args)
if args[0].is_a? Array
Drop.create(:bookmarks, args)
else
url, name = args[0], (args[1] || "")
Drop.create(:bookmark, {:name => name, :redirect_url => url})
end
end | ruby | {
"resource": ""
} |
q25714 | CloudApp.Client.rename | validation | def rename(id, name = "")
drop = Drop.find(id)
drop.update(:name => name)
end | ruby | {
"resource": ""
} |
q25715 | CloudApp.Client.privacy | validation | def privacy(id, privacy = false)
drop = Drop.find(id)
drop.update(:private => privacy)
end | ruby | {
"resource": ""
} |
q25716 | CloudApp.Base.load | validation | def load(attributes = {})
attributes.each do |key, val|
if key =~ /^.*_at$/ and val
# if this is a date/time key and it's not nil, try to parse it first
# as DateTime, then as Date only
begin
dt = DateTime.strptime(val, "%Y-%m-%dT%H:%M:%SZ")
newval = Time.utc(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec)
rescue ArgumentError => ex
newval = DateTime.strptime(val, "%Y-%m-%d")
end
self.instance_variable_set("@#{key}", newval)
else
self.instance_variable_set("@#{key}", val)
end
end
end | ruby | {
"resource": ""
} |
q25717 | WDSinatra.AppLoader.load_environment | validation | def load_environment(env=RACK_ENV)
# Load the default which can be overwritten or extended by specific
# env config files.
require File.join(root_path, 'config', 'environments', 'default.rb')
env_file = File.join(root_path, "config", "environments", "#{env}.rb")
if File.exist?(env_file)
require env_file
else
debug_msg = "Environment file: #{env_file} couldn't be found, using only the default environment config instead." unless env == 'development'
end
# making sure we have a LOGGER constant defined.
unless Object.const_defined?(:LOGGER)
Object.const_set(:LOGGER, Logger.new($stdout))
end
LOGGER.debug(debug_msg) if debug_msg
end | ruby | {
"resource": ""
} |
q25718 | WDSinatra.AppLoader.load_apis | validation | def load_apis
Dir.glob(File.join(root_path, "api", "**", "*.rb")).each do |api|
require api
end
end | ruby | {
"resource": ""
} |
q25719 | IsItWorking.Filter.run | validation | def run
status = Status.new(name)
runner = (async ? AsyncRunner : SyncRunner).new do
t = Time.now
begin
@check.call(status)
rescue Exception => e
status.fail("#{name} error: #{e.inspect}")
end
status.time = Time.now - t
end
runner.filter_status = status
runner
end | ruby | {
"resource": ""
} |
q25720 | IsItWorking.Handler.call | validation | def call(env)
if @app.nil? || env[PATH_INFO] == @route_path
statuses = []
t = Time.now
statuses = Filter.run_filters(@filters)
render(statuses, Time.now - t)
else
@app.call(env)
end
end | ruby | {
"resource": ""
} |
q25721 | IsItWorking.Handler.check | validation | def check (name, *options_or_check, &block)
raise ArgumentError("Too many arguments to #{self.class.name}#check") if options_or_check.size > 2
check = nil
options = {:async => true}
unless options_or_check.empty?
if options_or_check[0].is_a?(Hash)
options = options.merge(options_or_check[0])
else
check = options_or_check[0]
end
if options_or_check[1].is_a?(Hash)
options = options.merge(options_or_check[1])
end
end
unless check
if block
check = block
else
check = lookup_check(name, options)
end
end
@filters << Filter.new(name, check, options[:async])
end | ruby | {
"resource": ""
} |
q25722 | IsItWorking.Handler.lookup_check | validation | def lookup_check(name, options) #:nodoc:
check_class_name = "#{name.to_s.gsub(/(^|_)([a-z])/){|m| m.sub('_', '').upcase}}Check"
check = nil
if IsItWorking.const_defined?(check_class_name)
check_class = IsItWorking.const_get(check_class_name)
check = check_class.new(options)
else
raise ArgumentError.new("Check not defined #{check_class_name}")
end
check
end | ruby | {
"resource": ""
} |
q25723 | IsItWorking.Handler.render | validation | def render(statuses, elapsed_time) #:nodoc:
fail = statuses.all?{|s| s.success?}
headers = {
"Content-Type" => "text/plain; charset=utf8",
"Cache-Control" => "no-cache",
"Date" => Time.now.httpdate,
}
messages = []
statuses.each do |status|
status.messages.each do |m|
messages << "#{m.ok? ? 'OK: ' : 'FAIL:'} #{status.name} - #{m.message} (#{status.time ? sprintf('%0.000f', status.time * 1000) : '?'}ms)"
end
end
info = []
info << "Host: #{@hostname}" unless @hostname.size == 0
info << "PID: #{$$}"
info << "Timestamp: #{Time.now.iso8601}"
info << "Elapsed Time: #{(elapsed_time * 1000).round}ms"
code = (fail ? 200 : 500)
[code, headers, [info.join("\n"), "\n\n", messages.join("\n")]]
end | ruby | {
"resource": ""
} |
q25724 | IsItWorking.PingCheck.call | validation | def call(status)
begin
ping(@host, @port)
status.ok("#{@alias} is accepting connections on port #{@port.inspect}")
rescue Errno::ECONNREFUSED
status.fail("#{@alias} is not accepting connections on port #{@port.inspect}")
rescue SocketError => e
status.fail("connection to #{@alias} on port #{@port.inspect} failed with '#{e.message}'")
rescue Timeout::Error
status.fail("#{@alias} did not respond on port #{@port.inspect} within #{@timeout} seconds")
end
end | ruby | {
"resource": ""
} |
q25725 | BootstrapAdmin.ControllerHelpers.respond_to? | validation | def respond_to? method, include_private = false
true if bootstrap_admin_config.respond_to? method
super method, include_private
end | ruby | {
"resource": ""
} |
q25726 | IsItWorking.UrlCheck.instantiate_http | validation | def instantiate_http #:nodoc:
http_class = nil
if @proxy && @proxy[:host]
http_class = Net::HTTP::Proxy(@proxy[:host], @proxy[:port], @proxy[:username], @proxy[:password])
else
http_class = Net::HTTP
end
http = http_class.new(@uri.host, @uri.port)
if @uri.scheme == 'https'
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_PEER
end
http.open_timeout = @open_timeout
http.read_timeout = @read_timeout
return http
end | ruby | {
"resource": ""
} |
q25727 | IsItWorking.UrlCheck.perform_http_request | validation | def perform_http_request #:nodoc:
request = Net::HTTP::Get.new(@uri.request_uri, @headers)
request.basic_auth(@username, @password) if @username || @password
http = instantiate_http
http.start do
http.request(request)
end
end | ruby | {
"resource": ""
} |
q25728 | Ftdi.Context.usb_open | validation | def usb_open(vendor, product)
raise ArgumentError.new('vendor should be Fixnum') unless vendor.kind_of?(Fixnum)
raise ArgumentError.new('product should be Fixnum') unless product.kind_of?(Fixnum)
check_result(Ftdi.ftdi_usb_open(ctx, vendor, product))
end | ruby | {
"resource": ""
} |
q25729 | Ftdi.Context.usb_open_desc | validation | def usb_open_desc(vendor, product, description, serial)
raise ArgumentError.new('vendor should be Fixnum') unless vendor.kind_of?(Fixnum)
raise ArgumentError.new('product should be Fixnum') unless product.kind_of?(Fixnum)
check_result(Ftdi.ftdi_usb_open_desc(ctx, vendor, product, description, serial))
end | ruby | {
"resource": ""
} |
q25730 | Ftdi.Context.usb_open_desc_index | validation | def usb_open_desc_index(vendor, product, description, serial, index)
raise ArgumentError.new('vendor should be Fixnum') unless vendor.kind_of?(Fixnum)
raise ArgumentError.new('product should be Fixnum') unless product.kind_of?(Fixnum)
raise ArgumentError.new('index should be Fixnum') unless index.kind_of?(Fixnum)
raise ArgumentError.new('index should be greater than or equal to zero') if index < 0
check_result(Ftdi.ftdi_usb_open_desc_index(ctx, vendor, product, description, serial, index))
end | ruby | {
"resource": ""
} |
q25731 | Ftdi.Context.baudrate= | validation | def baudrate=(new_baudrate)
raise ArgumentError.new('baudrate should be Fixnum') unless new_baudrate.kind_of?(Fixnum)
check_result(Ftdi.ftdi_set_baudrate(ctx, new_baudrate))
end | ruby | {
"resource": ""
} |
q25732 | Ftdi.Context.write_data_chunksize | validation | def write_data_chunksize
p = FFI::MemoryPointer.new(:uint, 1)
check_result(Ftdi.ftdi_write_data_get_chunksize(ctx, p))
p.read_uint
end | ruby | {
"resource": ""
} |
q25733 | Ftdi.Context.write_data | validation | def write_data(bytes)
bytes = bytes.pack('c*') if bytes.respond_to?(:pack)
size = bytes.respond_to?(:bytesize) ? bytes.bytesize : bytes.size
mem_buf = FFI::MemoryPointer.new(:char, size)
mem_buf.put_bytes(0, bytes)
bytes_written = Ftdi.ftdi_write_data(ctx, mem_buf, size)
check_result(bytes_written)
bytes_written
end | ruby | {
"resource": ""
} |
q25734 | Ftdi.Context.read_data_chunksize | validation | def read_data_chunksize
p = FFI::MemoryPointer.new(:uint, 1)
check_result(Ftdi.ftdi_read_data_get_chunksize(ctx, p))
p.read_uint
end | ruby | {
"resource": ""
} |
q25735 | Ftdi.Context.read_data | validation | def read_data
chunksize = read_data_chunksize
p = FFI::MemoryPointer.new(:char, chunksize)
bytes_read = Ftdi.ftdi_read_data(ctx, p, chunksize)
check_result(bytes_read)
r = p.read_bytes(bytes_read)
r.force_encoding("ASCII-8BIT") if r.respond_to?(:force_encoding)
r
end | ruby | {
"resource": ""
} |
q25736 | Ftdi.Context.read_pins | validation | def read_pins
p = FFI::MemoryPointer.new(:uchar, 1)
check_result(Ftdi.ftdi_read_pins(ctx, p))
p.read_uchar
end | ruby | {
"resource": ""
} |
q25737 | Geos::GoogleMaps::Api2.Geometry.to_g_marker_api2 | validation | def to_g_marker_api2(marker_options = {}, options = {})
klass = if options[:short_class]
'GMarker'
else
'google.maps.Marker'
end
opts = Geos::Helper.camelize_keys(marker_options)
"new #{klass}(#{self.centroid.to_g_lat_lng(options)}, #{opts.to_json})"
end | ruby | {
"resource": ""
} |
q25738 | Geos::GoogleMaps::Api2.CoordinateSequence.to_g_polyline_api2 | validation | def to_g_polyline_api2(polyline_options = {}, options = {})
klass = if options[:short_class]
'GPolyline'
else
'google.maps.Polyline'
end
poly_opts = if polyline_options[:polyline_options]
Geos::Helper.camelize_keys(polyline_options[:polyline_options])
end
args = [
(polyline_options[:color] ? "'#{Geos::Helper.escape_javascript(polyline_options[:color])}'" : 'null'),
(polyline_options[:weight] || 'null'),
(polyline_options[:opacity] || 'null'),
(poly_opts ? poly_opts.to_json : 'null')
].join(', ')
"new #{klass}([#{self.to_g_lat_lng(options).join(', ')}], #{args})"
end | ruby | {
"resource": ""
} |
q25739 | Geos::GoogleMaps::Api2.CoordinateSequence.to_g_polygon_api2 | validation | def to_g_polygon_api2(polygon_options = {}, options = {})
klass = if options[:short_class]
'GPolygon'
else
'google.maps.Polygon'
end
poly_opts = if polygon_options[:polygon_options]
Geos::Helper.camelize_keys(polygon_options[:polygon_options])
end
args = [
(polygon_options[:stroke_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:stroke_color])}'" : 'null'),
(polygon_options[:stroke_weight] || 'null'),
(polygon_options[:stroke_opacity] || 'null'),
(polygon_options[:fill_color] ? "'#{Geos::Helper.escape_javascript(polygon_options[:fill_color])}'" : 'null'),
(polygon_options[:fill_opacity] || 'null'),
(poly_opts ? poly_opts.to_json : 'null')
].join(', ')
"new #{klass}([#{self.to_g_lat_lng_api2(options).join(', ')}], #{args})"
end | ruby | {
"resource": ""
} |
q25740 | Geos.Geometry.to_bbox | validation | def to_bbox(long_or_short_names = :long)
case long_or_short_names
when :long
{
:north => self.north,
:east => self.east,
:south => self.south,
:west => self.west
}
when :short
{
:n => self.north,
:e => self.east,
:s => self.south,
:w => self.west
}
else
raise ArgumentError.new("Expected either :long or :short for long_or_short_names argument")
end
end | ruby | {
"resource": ""
} |
q25741 | Geos.Point.to_georss | validation | def to_georss(*args)
xml = Geos::Helper.xml_options(*args)[0]
xml.georss(:where) do
xml.gml(:Point) do
xml.gml(:pos, "#{self.lat} #{self.lng}")
end
end
end | ruby | {
"resource": ""
} |
q25742 | Geos::GoogleMaps.Api3::Geometry.to_g_marker_api3 | validation | def to_g_marker_api3(marker_options = {}, options = {})
options = {
:escape => [],
:lat_lng_options => {}
}.merge(options)
opts = Geos::Helper.camelize_keys(marker_options)
opts[:position] = self.centroid.to_g_lat_lng(options[:lat_lng_options])
json = Geos::Helper.escape_json(opts, Geos::GoogleMaps::Api3Constants::UNESCAPED_MARKER_OPTIONS - options[:escape])
"new google.maps.Marker(#{json})"
end | ruby | {
"resource": ""
} |
q25743 | Geos::GoogleMaps.Api3::CoordinateSequence.to_g_polyline_api3 | validation | def to_g_polyline_api3(polyline_options = {}, options = {})
options = {
:escape => [],
:lat_lng_options => {}
}.merge(options)
opts = Geos::Helper.camelize_keys(polyline_options)
opts[:path] = "[#{self.to_g_lat_lng_api3(options[:lat_lng_options]).join(', ')}]"
json = Geos::Helper.escape_json(opts, Geos::GoogleMaps::Api3Constants::UNESCAPED_POLY_OPTIONS - options[:escape])
"new google.maps.Polyline(#{json})"
end | ruby | {
"resource": ""
} |
q25744 | Geos.CoordinateSequence.to_georss | validation | def to_georss(*args)
xml = Geos::Helper.xml_options(*args)[0]
xml.georss(:where) do
xml.gml(:LineString) do
xml.gml(:posList) do
xml << self.to_a.collect do |p|
"#{p[1]} #{p[0]}"
end.join(' ')
end
end
end
end | ruby | {
"resource": ""
} |
q25745 | SolidusImportProducts.ProcessRow.convert_to_price | validation | def convert_to_price(price_str)
raise SolidusImportProducts::Exception::InvalidPrice unless price_str
punt = price_str.index('.')
coma = price_str.index(',')
if !coma.nil? && !punt.nil?
price_str.gsub!(punt < coma ? '.' : ',', '')
end
price_str.tr(',', '.').to_f
end | ruby | {
"resource": ""
} |
q25746 | SynchronizedModel.Support.matches | validation | def matches(regexp, word)
if regexp.respond_to?(:match?)
regexp.match?(word)
else
regexp.match(word)
end
end | ruby | {
"resource": ""
} |
q25747 | Geos.Polygon.dump_points | validation | def dump_points(cur_path = [])
points = [ self.exterior_ring.dump_points ]
self.interior_rings.each do |ring|
points.push(ring.dump_points)
end
cur_path.concat(points)
end | ruby | {
"resource": ""
} |
q25748 | PruneAr.ForeignKeyHandler.generate_belongs_to_foreign_key_name | validation | def generate_belongs_to_foreign_key_name(assoc)
source = assoc.source_table[0..7]
column = assoc.foreign_key_column[0..7]
destination = assoc.destination_table[0..7]
"fk_#{source}_#{column}_#{destination}_#{SecureRandom.hex}"
end | ruby | {
"resource": ""
} |
q25749 | EGPRates.CIB.raw_exchange_rates | validation | def raw_exchange_rates
req = Net::HTTP::Post.new(@uri, 'Content-Type' => 'application/json')
req.body = { lang: :en }.to_json
response = Net::HTTP.start(@uri.hostname, @uri.port) do |http|
http.request(req)
end
fail ResponseError, response.code unless response.is_a? Net::HTTPSuccess
response = JSON.parse(response.body)
# CIB provide 6 currencies only
unless response['d'] && response['d'].size >= 6
fail ResponseError, "Unknown JSON #{response}"
end
response
rescue JSON::ParserError
raise ResponseError, "Unknown JSON: #{response.body}"
end | ruby | {
"resource": ""
} |
q25750 | Respect.FormatValidator.validate_ipv4_addr | validation | def validate_ipv4_addr(value)
ipaddr = IPAddr.new(value)
unless ipaddr.ipv4?
raise ValidationError, "IP address '#{value}' is not IPv4"
end
ipaddr
rescue ArgumentError => e
raise ValidationError, "invalid IPv4 address '#{value}' - #{e.message}"
end | ruby | {
"resource": ""
} |
q25751 | Respect.FormatValidator.validate_ipv6_addr | validation | def validate_ipv6_addr(value)
ipaddr = IPAddr.new(value)
unless ipaddr.ipv6?
raise ValidationError, "IP address '#{value}' is not IPv6"
end
ipaddr
rescue ArgumentError => e
raise ValidationError, "invalid IPv6 address '#{value}' - #{e.message}"
end | ruby | {
"resource": ""
} |
q25752 | LazyLazer.InternalModel.to_h | validation | def to_h(strict: false)
todo = @key_metadata.keys - @cache.keys
todo.each_with_object({}) do |key, hsh|
loaded_key = (strict ? load_key_strict(key) : load_key_lenient(key))
hsh[key] = loaded_key if exists_locally?(key)
end
end | ruby | {
"resource": ""
} |
q25753 | LazyLazer.InternalModel.exists_locally? | validation | def exists_locally?(key_name)
return true if @cache.key?(key_name) || @writethrough.key?(key_name)
meta = ensure_metadata_exists(key_name)
@source.key?(meta.source_key)
end | ruby | {
"resource": ""
} |
q25754 | LazyLazer.InternalModel.write_attribute | validation | def write_attribute(key_name, new_value)
meta = ensure_metadata_exists(key_name)
@source.delete(meta.source_key)
@writethrough[key_name] = @cache[key_name] = new_value
end | ruby | {
"resource": ""
} |
q25755 | LazyLazer.InternalModel.delete_attribute | validation | def delete_attribute(key_name)
key_name_sym = key_name.to_sym
meta = ensure_metadata_exists(key_name_sym)
@cache.delete(key_name)
@writethrough.delete(key_name)
@source.delete(meta.source_key)
nil
end | ruby | {
"resource": ""
} |
q25756 | LazyLazer.InternalModel.verify_required! | validation | def verify_required!
@key_metadata.required_properties.each do |key_name|
next if @source.key?(@key_metadata.get(key_name).source_key)
raise RequiredAttribute, "#{@parent} requires `#{key_name}`"
end
end | ruby | {
"resource": ""
} |
q25757 | LazyLazer.InternalModel.transform_value | validation | def transform_value(value, transform)
case transform
when nil
value
when Proc
@parent.instance_exec(value, &transform)
when Symbol
value.public_send(transform)
end
end | ruby | {
"resource": ""
} |
q25758 | EGPRates.Bank.response | validation | def response
response = Net::HTTP.get_response(@uri)
if response.is_a? Net::HTTPRedirection
response = Net::HTTP.get_response(URI.parse(response['location']))
end
fail ResponseError, response.code unless response.is_a? Net::HTTPSuccess
response
end | ruby | {
"resource": ""
} |
q25759 | EGPRates.ADIB.currencies | validation | def currencies(table_rows)
table_rows.lazy.map do |e|
e.css('img').map { |img| img.attribute('src').value }
end.force.flatten
end | ruby | {
"resource": ""
} |
q25760 | LazyLazer.KeyMetadataStore.add | validation | def add(key, meta)
@collection[key] = meta
if meta.required?
@required_properties << key
else
@required_properties.delete(key)
end
meta
end | ruby | {
"resource": ""
} |
q25761 | Respect.HasConstraints.validate_constraints | validation | def validate_constraints(value)
options.each do |option, arg|
if validator_class = Respect.validator_for(option)
validator_class.new(arg).validate(value)
end
end
end | ruby | {
"resource": ""
} |
q25762 | Respect.HasConstraints.validate | validation | def validate(object)
sanitized_object = validate_type(object)
validate_constraints(sanitized_object) unless sanitized_object.nil? && allow_nil?
self.sanitized_object = sanitized_object
true
rescue ValidationError => e
# Reset sanitized object.
self.sanitized_object = nil
raise e
end | ruby | {
"resource": ""
} |
q25763 | Respect.HashSchema.[]= | validation | def []=(name, schema)
case name
when Symbol, String, Regexp
if @properties.has_key?(name)
raise InvalidSchemaError, "property '#{name}' already defined"
end
@properties[name] = schema
else
raise InvalidSchemaError, "unsupported property name type #{name}:#{name.class}"
end
end | ruby | {
"resource": ""
} |
q25764 | Respect.HashDef.[]= | validation | def []=(key, value)
case value
when String
string(key, equal_to: value.to_s)
else
any(key, equal_to: value.to_s)
end
end | ruby | {
"resource": ""
} |
q25765 | GoogleHolidayCalendar.Calendar.holiday? | validation | def holiday?(arg)
date = to_date(arg)
holidays(start_date: date, end_date: date + 1.day, limit: 1).length > 0
end | ruby | {
"resource": ""
} |
q25766 | Choice.Parser.arrayize_arguments | validation | def arrayize_arguments(args)
# Go through trailing arguments and suck them in if they don't seem
# to have an owner.
array = []
until args.empty? || args.first.match(/^-/)
array << args.shift
end
array
end | ruby | {
"resource": ""
} |
q25767 | Choice.Option.to_a | validation | def to_a
[
required,
short,
long,
desc,
default,
filter,
action,
cast,
valid,
validate
].compact
end | ruby | {
"resource": ""
} |
q25768 | Choice.Option.to_h | validation | def to_h
{
"required" => required,
"short" => short,
"long" => long,
"desc" => desc,
"default" => default,
"filter" => filter,
"action" => action,
"cast" => cast,
"valid" => valid,
"validate" => validate
}.reject {|k, v| v.nil? }
end | ruby | {
"resource": ""
} |
q25769 | EventHub.Configuration.parse_options | validation | def parse_options(argv = ARGV)
@config_file = File.join(Dir.getwd, 'config', "#{@name}.json")
OptionParser.new do |opts|
note = 'Define environment'
opts.on('-e', '--environment ENVIRONMENT', note) do |environment|
@environment = environment
end
opts.on('-d', '--detached', 'Run processor detached as a daemon') do
@detached = true
end
note = 'Define configuration file'
opts.on('-c', '--config CONFIG', note) do |config|
@config_file = config
end
end.parse!(argv)
true
rescue OptionParser::InvalidOption => e
EventHub.logger.warn("Argument Parsing: #{e}")
false
rescue OptionParser::MissingArgument => e
EventHub.logger.warn("Argument Parsing: #{e}")
false
end | ruby | {
"resource": ""
} |
q25770 | EventHub.Configuration.load! | validation | def load!(args = {})
# for better rspec testing
@config_file = args[:config_file] if args[:config_file]
@environment = args[:environment] if args[:environment]
new_data = {}
begin
new_data = JSON.parse(File.read(@config_file), symbolize_names: true)
rescue => e
EventHub.logger.warn("Exception while loading configuration file: #{e}")
EventHub.logger.info('Using default configuration values')
end
deep_merge!(@config_data, default_configuration)
new_data = new_data[@environment.to_sym]
deep_merge!(@config_data, new_data)
end | ruby | {
"resource": ""
} |
q25771 | Vidibus.Words.keywords | validation | def keywords(limit = 20)
@keywords ||= {}
@keywords[limit] ||= begin
list = []
count = 0
_stopwords = Vidibus::Words.stopwords(*locales)
for word in sort
clean = word.permalink.gsub('-','')
unless _stopwords.include?(clean)
list << word
count += 1
break if count >= limit
end
end
list
end
end | ruby | {
"resource": ""
} |
q25772 | ONIX.Normaliser.next_tempfile | validation | def next_tempfile
p = nil
Tempfile.open("onix") do |tf|
p = tf.path
tf.close!
end
p
end | ruby | {
"resource": ""
} |
q25773 | ONIX.Reader.each | validation | def each(&block)
@reader.each do |node|
if @reader.node_type == 1 && @reader.name == "Product"
str = @reader.outer_xml
if str.nil?
yield @product_klass.new
else
yield @product_klass.from_xml(str)
end
end
end
end | ruby | {
"resource": ""
} |
q25774 | ONIX.APAProduct.title | validation | def title
composite = product.titles.first
if composite.nil?
nil
else
composite.title_text || composite.title_without_prefix
end
end | ruby | {
"resource": ""
} |
q25775 | ONIX.APAProduct.title= | validation | def title=(str)
composite = product.titles.first
if composite.nil?
composite = ONIX::Title.new
composite.title_type = 1
product.titles << composite
end
composite.title_text = str
end | ruby | {
"resource": ""
} |
q25776 | ONIX.APAProduct.subtitle= | validation | def subtitle=(str)
composite = product.titles.first
if composite.nil?
composite = ONIX::Title.new
composite.title_type = 1
product.titles << composite
end
composite.subtitle = str
end | ruby | {
"resource": ""
} |
q25777 | ONIX.APAProduct.bic_subjects | validation | def bic_subjects
subjects = product.subjects.select { |sub| sub.subject_scheme_id.to_i == 12 }
subjects.collect { |sub| sub.subject_code}
end | ruby | {
"resource": ""
} |
q25778 | ONIX.APAProduct.imprint= | validation | def imprint=(str)
composite = product.imprints.first
if composite.nil?
composite = ONIX::Imprint.new
product.imprints << composite
end
composite.imprint_name = str
end | ruby | {
"resource": ""
} |
q25779 | ONIX.APAProduct.sales_restriction_type= | validation | def sales_restriction_type=(type)
composite = product.sales_restrictions.first
if composite.nil?
composite = ONIX::SalesRestriction.new
product.sales_restrictions << composite
end
composite.sales_restriction_type = type
end | ruby | {
"resource": ""
} |
q25780 | ONIX.APAProduct.on_order | validation | def on_order
supply = find_or_create_supply_detail
composite = supply.stock.first
if composite.nil?
composite = ONIX::Stock.new
supply.stock << composite
end
composite.on_order
end | ruby | {
"resource": ""
} |
q25781 | ONIX.APAProduct.proprietry_discount_code_for_rrp | validation | def proprietry_discount_code_for_rrp
price = price_get(2)
return nil if price.nil?
discount = price.discounts_coded.find { |disc| disc.discount_code_type == 2 }
discount.andand.discount_code
end | ruby | {
"resource": ""
} |
q25782 | ONIX.APAProduct.proprietry_discount_code_for_rrp= | validation | def proprietry_discount_code_for_rrp=(code)
price = price_get(2)
if price.nil?
self.rrp_inc_sales_tax = 0
price = price_get(2)
end
discount = price.discounts_coded.find { |disc| disc.discount_code_type == 2 }
if discount.nil?
discount = ONIX::DiscountCoded.new
discount.discount_code_type = 2
price.discounts_coded << discount
end
discount.discount_code = code
end | ruby | {
"resource": ""
} |
q25783 | ONIX.APAProduct.add_subject | validation | def add_subject(str, type = "12")
subject = ::ONIX::Subject.new
subject.subject_scheme_id = type.to_i
subject.subject_code = str
product.subjects << subject
end | ruby | {
"resource": ""
} |
q25784 | ONIX.APAProduct.measurement_set | validation | def measurement_set(type, value, unit)
measure = measurement(type)
# create a new isbn record if we need to
if measure.nil?
measure = ONIX::Measure.new
measure.measure_type_code = type
product.measurements << measure
end
# store the new value
measure.measurement = value
measure.measure_unit_code = unit.to_s
end | ruby | {
"resource": ""
} |
q25785 | ONIX.APAProduct.price_get | validation | def price_get(type)
supply = find_or_create_supply_detail
if type.nil?
supply.prices.first
else
supply.prices.find { |p| p.price_type_code == type }
end
end | ruby | {
"resource": ""
} |
q25786 | ONIX.APAProduct.price_set | validation | def price_set(type, num)
p = price_get(type)
# create a new isbn record if we need to
if p.nil?
supply = find_or_create_supply_detail
p = ONIX::Price.new
p.price_type_code = type
supply.prices << p
end
# store the new value
p.price_amount = num
end | ruby | {
"resource": ""
} |
q25787 | ONIX.APAProduct.other_text_set | validation | def other_text_set(type, value)
text = other_text(type)
if text.nil?
text = ONIX::OtherText.new
text.text_type_code = type
product.text << text
end
# store the new value
text.text = value.to_s
end | ruby | {
"resource": ""
} |
q25788 | ONIX.APAProduct.website_set | validation | def website_set(type, value)
site = website(type)
# create a new website record if we need to
if site.nil?
site = ONIX::Website.new
site.website_role = type
product.websites << site
end
site.website_link = value.to_s
end | ruby | {
"resource": ""
} |
q25789 | Popular.Popular.befriend | validation | def befriend new_friend
run_callbacks :befriend do
friendships.create friend_id: new_friend.id, friend_type: new_friend.class.name
end
end | ruby | {
"resource": ""
} |
q25790 | Popular.Popular.befriend! | validation | def befriend! new_friend
run_callbacks :befriend do
friendships.create! friend_id: new_friend.id, friend_type: new_friend.class.name
end
end | ruby | {
"resource": ""
} |
q25791 | Popular.Popular.unfriend | validation | def unfriend friend
run_callbacks :unfriend do
friendships
.where( friend_type: friend.class.name )
.where( friend_id: friend.id )
.first.destroy
end
end | ruby | {
"resource": ""
} |
q25792 | TimecopConsole.ControllerMethods.handle_timecop_offset | validation | def handle_timecop_offset
# Establish now
if session[TimecopConsole::SESSION_KEY_NAME].present?
Rails.logger.debug "[timecop-console] Time traveling to #{session[TimecopConsole::SESSION_KEY_NAME].to_s}"
Timecop.travel(session[TimecopConsole::SESSION_KEY_NAME])
else
Timecop.return
end
# Run the intended action
yield
if session[TimecopConsole::SESSION_KEY_NAME].present?
# we want to continue to slide time forward, even if it's only 3 seconds at a time.
# this ensures that subsequent calls during the same "time travel" actually pass time
adjusted_time = Time.now + 3
Rails.logger.debug "[timecop-console] Resetting session to: #{adjusted_time}"
session[TimecopConsole::SESSION_KEY_NAME] = adjusted_time
end
end | ruby | {
"resource": ""
} |
q25793 | CodeMetrics.StatsDirectories.default_app_directories | validation | def default_app_directories
StatDirectory.from_list([
%w(Controllers app/controllers),
%w(Helpers app/helpers),
%w(Models app/models),
%w(Mailers app/mailers),
%w(Javascripts app/assets/javascripts),
%w(Libraries lib),
%w(APIs app/apis)
], @root)
end | ruby | {
"resource": ""
} |
q25794 | CodeMetrics.StatsDirectories.collect_directories | validation | def collect_directories(glob_pattern, file_pattern='')
Pathname.glob(glob_pattern).select{|f| f.basename.to_s.include?(file_pattern) }.map(&:dirname).uniq.map(&:realpath)
end | ruby | {
"resource": ""
} |
q25795 | Ws2812.Basic.[]= | validation | def []=(index, color)
if index.respond_to?(:to_a)
index.to_a.each do |i|
check_index(i)
ws2811_led_set(@channel, i, color.to_i)
end
else
check_index(index)
ws2811_led_set(@channel, index, color.to_i)
end
end | ruby | {
"resource": ""
} |
q25796 | Ws2812.Basic.set | validation | def set(index, r, g, b)
check_index(index)
self[index] = Color.new(r, g, b)
end | ruby | {
"resource": ""
} |
q25797 | Ws2812.Basic.[] | validation | def [](index)
if index.respond_to?(:to_a)
index.to_a.map do |i|
check_index(i)
Color.from_i(ws2811_led_get(@channel, i))
end
else
check_index(index)
Color.from_i(ws2811_led_get(@channel, index))
end
end | ruby | {
"resource": ""
} |
q25798 | ChefFS.Config.format_path | validation | def format_path(entry)
server_path = entry.path
if base_path && server_path[0,base_path.length] == base_path
if server_path == base_path
return "."
elsif server_path[base_path.length,1] == "/"
return server_path[base_path.length + 1, server_path.length - base_path.length - 1]
elsif base_path == "/" && server_path[0,1] == "/"
return server_path[1, server_path.length - 1]
end
end
server_path
end | ruby | {
"resource": ""
} |
q25799 | ChefFS.FilePattern.exact_path | validation | def exact_path
return nil if has_double_star || exact_parts.any? { |part| part.nil? }
result = ChefFS::PathUtils::join(*exact_parts)
is_absolute ? ChefFS::PathUtils::join('', result) : result
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.