_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q12800 | Magick.Image.texture_floodfill | train | def texture_floodfill(x, y, texture)
target = pixel_color(x, y)
texture_flood_fill(target, texture, x, y, FloodfillMethod)
end | ruby | {
"resource": ""
} |
q12801 | Magick.Image.texture_fill_to_border | train | def texture_fill_to_border(x, y, texture)
texture_flood_fill(border_color, texture, x, y, FillToBorderMethod)
end | ruby | {
"resource": ""
} |
q12802 | Magick.Image.view | train | def view(x, y, width, height)
view = View.new(self, x, y, width, height)
return view unless block_given?
begin
yield(view)
ensure
view.sync
end
nil
end | ruby | {
"resource": ""
} |
q12803 | Magick.ImageList.set_current | train | def set_current(current)
if length.zero?
self.scene = nil
return
# Don't bother looking for current image
elsif scene.nil? || scene >= length
self.scene = length - 1
return
elsif !current.nil?
# Find last instance of "current" in the list.
# If "current" isn't in the list, set current to last image.
self.scene = length - 1
each_with_index do |f, i|
self.scene = i if f.__id__ == current
end
return
end
self.scene = length - 1
end | ruby | {
"resource": ""
} |
q12804 | Magick.ImageList.scene= | train | def scene=(n)
if n.nil?
Kernel.raise IndexError, 'scene number out of bounds' unless @images.length.zero?
@scene = nil
return @scene
elsif @images.length.zero?
Kernel.raise IndexError, 'scene number out of bounds'
end
n = Integer(n)
Kernel.raise IndexError, 'scene number out of bounds' if n < 0 || n > length - 1
@scene = n
@scene
end | ruby | {
"resource": ""
} |
q12805 | Magick.ImageList.copy | train | def copy
ditto = self.class.new
@images.each { |f| ditto << f.copy }
ditto.scene = @scene
ditto.taint if tainted?
ditto
end | ruby | {
"resource": ""
} |
q12806 | Magick.ImageList.delay= | train | def delay=(d)
raise ArgumentError, 'delay must be greater than or equal to 0' if Integer(d) < 0
@images.each { |f| f.delay = Integer(d) }
end | ruby | {
"resource": ""
} |
q12807 | Magick.ImageList.insert | train | def insert(index, *args)
args.each { |image| is_an_image image }
current = get_current
@images.insert(index, *args)
set_current current
self
end | ruby | {
"resource": ""
} |
q12808 | Magick.ImageList.inspect | train | def inspect
img = []
@images.each { |image| img << image.inspect }
img = '[' + img.join(",\n") + "]\nscene=#{@scene}"
end | ruby | {
"resource": ""
} |
q12809 | Magick.ImageList.iterations= | train | def iterations=(n)
n = Integer(n)
Kernel.raise ArgumentError, 'iterations must be between 0 and 65535' if n < 0 || n > 65_535
@images.each { |f| f.iterations = n }
self
end | ruby | {
"resource": ""
} |
q12810 | Magick.ImageList.new_image | train | def new_image(cols, rows, *fill, &info_blk)
self << Magick::Image.new(cols, rows, *fill, &info_blk)
end | ruby | {
"resource": ""
} |
q12811 | Magick.ImageList.read | train | def read(*files, &block)
Kernel.raise ArgumentError, 'no files given' if files.length.zero?
files.each do |f|
Magick::Image.read(f, &block).each { |n| @images << n }
end
@scene = length - 1
self
end | ruby | {
"resource": ""
} |
q12812 | Magick.ImageList.reject | train | def reject(&block)
current = get_current
ilist = self.class.new
a = @images.reject(&block)
a.each { |image| ilist << image }
ilist.set_current current
ilist
end | ruby | {
"resource": ""
} |
q12813 | Magick.Image.alpha_hist | train | def alpha_hist(freqs, scale, fg, bg)
histogram = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) do
self.background_color = bg
self.border_color = fg
end
gc = Draw.new
gc.affine(1, 0, 0, -scale, 0, HISTOGRAM_ROWS)
gc.fill('white')
HISTOGRAM_COLS.times do |x|
gc.point(x, freqs[x])
end
gc.draw(histogram)
histogram['Label'] = 'Alpha'
histogram
end | ruby | {
"resource": ""
} |
q12814 | Magick.Image.color_hist | train | def color_hist(fg, bg)
img = number_colors > 256 ? quantize(256) : self
begin
hist = img.color_histogram
rescue NotImplementedError
warn 'The color_histogram method is not supported by this version '\
'of ImageMagick/GraphicsMagick'
else
pixels = hist.keys.sort_by { |pixel| hist[pixel] }
scale = HISTOGRAM_ROWS / (hist.values.max * AIR_FACTOR)
histogram = Image.new(HISTOGRAM_COLS, HISTOGRAM_ROWS) do
self.background_color = bg
self.border_color = fg
end
x = 0
pixels.each do |pixel|
column = Array.new(HISTOGRAM_ROWS).fill { Pixel.new }
HISTOGRAM_ROWS.times do |y|
column[y] = pixel if y >= HISTOGRAM_ROWS - (hist[pixel] * scale)
end
histogram.store_pixels(x, 0, 1, HISTOGRAM_ROWS, column)
x = x.succ
end
histogram['Label'] = 'Color Frequency'
return histogram
end
end | ruby | {
"resource": ""
} |
q12815 | Magick.Image.pixel_intensity | train | def pixel_intensity(pixel)
(306 * (pixel.red & MAX_QUANTUM) + 601 * (pixel.green & MAX_QUANTUM) + 117 * (pixel.blue & MAX_QUANTUM)) / 1024
end | ruby | {
"resource": ""
} |
q12816 | Magick.Image.histogram | train | def histogram(fg = 'white', bg = 'black')
red = Array.new(HISTOGRAM_COLS, 0)
green = Array.new(HISTOGRAM_COLS, 0)
blue = Array.new(HISTOGRAM_COLS, 0)
alpha = Array.new(HISTOGRAM_COLS, 0)
int = Array.new(HISTOGRAM_COLS, 0)
rows.times do |row|
pixels = get_pixels(0, row, columns, 1)
pixels.each do |pixel|
red[pixel.red & MAX_QUANTUM] += 1
green[pixel.green & MAX_QUANTUM] += 1
blue[pixel.blue & MAX_QUANTUM] += 1
# Only count opacity channel if some pixels are not opaque.
alpha[pixel.opacity & MAX_QUANTUM] += 1 unless opaque?
v = pixel_intensity(pixel)
int[v] += 1
end
end
# Scale to chart size. When computing the scale, add some "air" between
# the max frequency and the top of the histogram. This makes a prettier chart.
# The RGBA and intensity histograms are all drawn to the same scale.
max = [red.max, green.max, blue.max, alpha.max, int.max].max
scale = HISTOGRAM_ROWS / (max * AIR_FACTOR)
charts = ImageList.new
# Add the thumbnail.
thumb = copy
thumb['Label'] = File.basename(filename)
charts << thumb
# Compute the channel and intensity histograms.
channel_hists = channel_histograms(red, green, blue, int, scale, fg, bg)
# Add the red, green, and blue histograms to the list
charts << channel_hists.shift
charts << channel_hists.shift
charts << channel_hists.shift
# Add Alpha channel or image stats
charts << if !opaque?
alpha_hist(alpha, scale, fg, bg)
else
info_text(fg, bg)
end
# Add the RGB histogram
charts << channel_hists.shift
# Add the intensity histogram.
charts << intensity_hist(channel_hists.shift)
# Add the color frequency histogram.
charts << color_hist(fg, bg)
# Make a montage.
histogram = charts.montage do
self.background_color = bg
self.stroke = 'transparent'
self.fill = fg
self.border_width = 1
self.tile = '4x2'
self.geometry = "#{HISTOGRAM_COLS}x#{HISTOGRAM_ROWS}+10+10"
end
histogram
end | ruby | {
"resource": ""
} |
q12817 | Dalli.Client.get_cas | train | def get_cas(key)
(value, cas) = perform(:cas, key)
value = (!value || value == 'Not found') ? nil : value
if block_given?
yield value, cas
else
[value, cas]
end
end | ruby | {
"resource": ""
} |
q12818 | Dalli.Client.set_cas | train | def set_cas(key, value, cas, ttl=nil, options=nil)
ttl ||= @options[:expires_in].to_i
perform(:set, key, value, ttl, cas, options)
end | ruby | {
"resource": ""
} |
q12819 | Dalli.Client.fetch | train | def fetch(key, ttl=nil, options=nil)
options = options.nil? ? CACHE_NILS : options.merge(CACHE_NILS) if @options[:cache_nils]
val = get(key, options)
not_found = @options[:cache_nils] ?
val == Dalli::Server::NOT_FOUND :
val.nil?
if not_found && block_given?
val = yield
add(key, val, ttl_or_default(ttl), options)
end
val
end | ruby | {
"resource": ""
} |
q12820 | Dalli.Client.cas | train | def cas(key, ttl=nil, options=nil, &block)
cas_core(key, false, ttl, options, &block)
end | ruby | {
"resource": ""
} |
q12821 | Dalli.Client.incr | train | def incr(key, amt=1, ttl=nil, default=nil)
raise ArgumentError, "Positive values only: #{amt}" if amt < 0
perform(:incr, key, amt.to_i, ttl_or_default(ttl), default)
end | ruby | {
"resource": ""
} |
q12822 | Dalli.Client.touch | train | def touch(key, ttl=nil)
resp = perform(:touch, key, ttl_or_default(ttl))
resp.nil? ? nil : true
end | ruby | {
"resource": ""
} |
q12823 | Dalli.Client.version | train | def version
values = {}
ring.servers.each do |server|
values["#{server.name}"] = server.alive? ? server.request(:version) : nil
end
values
end | ruby | {
"resource": ""
} |
q12824 | Dalli.Client.get_multi_yielder | train | def get_multi_yielder(keys)
perform do
return {} if keys.empty?
ring.lock do
begin
groups = groups_for_keys(keys)
if unfound_keys = groups.delete(nil)
Dalli.logger.debug { "unable to get keys for #{unfound_keys.length} keys because no matching server was found" }
end
make_multi_get_requests(groups)
servers = groups.keys
return if servers.empty?
servers = perform_multi_response_start(servers)
start = Time.now
while true
# remove any dead servers
servers.delete_if { |s| s.sock.nil? }
break if servers.empty?
# calculate remaining timeout
elapsed = Time.now - start
timeout = servers.first.options[:socket_timeout]
time_left = (elapsed > timeout) ? 0 : timeout - elapsed
sockets = servers.map(&:sock)
readable, _ = IO.select(sockets, nil, nil, time_left)
if readable.nil?
# no response within timeout; abort pending connections
servers.each do |server|
Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
server.multi_response_abort
end
break
else
readable.each do |sock|
server = sock.server
begin
server.multi_response_nonblock.each_pair do |key, value_list|
yield key_without_namespace(key), value_list
end
if server.multi_response_completed?
servers.delete(server)
end
rescue NetworkError
servers.delete(server)
end
end
end
end
end
end
end
end | ruby | {
"resource": ""
} |
q12825 | Kubeclient.ClientMixin.delete_entity | train | def delete_entity(resource_name, name, namespace = nil, delete_options: {})
delete_options_hash = delete_options.to_hash
ns_prefix = build_namespace_prefix(namespace)
payload = delete_options_hash.to_json unless delete_options_hash.empty?
response = handle_exception do
rs = rest_client[ns_prefix + resource_name + "/#{name}"]
RestClient::Request.execute(
rs.options.merge(
method: :delete,
url: rs.url,
headers: { 'Content-Type' => 'application/json' }.merge(@headers),
payload: payload
)
)
end
format_response(@as, response.body)
end | ruby | {
"resource": ""
} |
q12826 | Kubeclient.ClientMixin.format_datetime | train | def format_datetime(value)
case value
when DateTime, Time
value.strftime('%FT%T.%9N%:z')
when String
value
else
raise ArgumentError, "unsupported type '#{value.class}' of time value '#{value}'"
end
end | ruby | {
"resource": ""
} |
q12827 | Addressable.Template.extract | train | def extract(uri, processor=nil)
match_data = self.match(uri, processor)
return (match_data ? match_data.mapping : nil)
end | ruby | {
"resource": ""
} |
q12828 | Addressable.Template.match | train | def match(uri, processor=nil)
uri = Addressable::URI.parse(uri)
mapping = {}
# First, we need to process the pattern, and extract the values.
expansions, expansion_regexp =
parse_template_pattern(pattern, processor)
return nil unless uri.to_str.match(expansion_regexp)
unparsed_values = uri.to_str.scan(expansion_regexp).flatten
if uri.to_str == pattern
return Addressable::Template::MatchData.new(uri, self, mapping)
elsif expansions.size > 0
index = 0
expansions.each do |expansion|
_, operator, varlist = *expansion.match(EXPRESSION)
varlist.split(',').each do |varspec|
_, name, modifier = *varspec.match(VARSPEC)
mapping[name] ||= nil
case operator
when nil, '+', '#', '/', '.'
unparsed_value = unparsed_values[index]
name = varspec[VARSPEC, 1]
value = unparsed_value
value = value.split(JOINERS[operator]) if value && modifier == '*'
when ';', '?', '&'
if modifier == '*'
if unparsed_values[index]
value = unparsed_values[index].split(JOINERS[operator])
value = value.inject({}) do |acc, v|
key, val = v.split('=')
val = "" if val.nil?
acc[key] = val
acc
end
end
else
if (unparsed_values[index])
name, value = unparsed_values[index].split('=')
value = "" if value.nil?
end
end
end
if processor != nil && processor.respond_to?(:restore)
value = processor.restore(name, value)
end
if processor == nil
if value.is_a?(Hash)
value = value.inject({}){|acc, (k, v)|
acc[Addressable::URI.unencode_component(k)] =
Addressable::URI.unencode_component(v)
acc
}
elsif value.is_a?(Array)
value = value.map{|v| Addressable::URI.unencode_component(v) }
else
value = Addressable::URI.unencode_component(value)
end
end
if !mapping.has_key?(name) || mapping[name].nil?
# Doesn't exist, set to value (even if value is nil)
mapping[name] = value
end
index = index + 1
end
end
return Addressable::Template::MatchData.new(uri, self, mapping)
else
return nil
end
end | ruby | {
"resource": ""
} |
q12829 | Addressable.Template.partial_expand | train | def partial_expand(mapping, processor=nil, normalize_values=true)
result = self.pattern.dup
mapping = normalize_keys(mapping)
result.gsub!( EXPRESSION ) do |capture|
transform_partial_capture(mapping, capture, processor, normalize_values)
end
return Addressable::Template.new(result)
end | ruby | {
"resource": ""
} |
q12830 | Addressable.Template.expand | train | def expand(mapping, processor=nil, normalize_values=true)
result = self.pattern.dup
mapping = normalize_keys(mapping)
result.gsub!( EXPRESSION ) do |capture|
transform_capture(mapping, capture, processor, normalize_values)
end
return Addressable::URI.parse(result)
end | ruby | {
"resource": ""
} |
q12831 | Addressable.Template.generate | train | def generate(params={}, recall={}, options={})
merged = recall.merge(params)
if options[:processor]
processor = options[:processor]
elsif options[:parameterize]
# TODO: This is sending me into fits trying to shoe-horn this into
# the existing API. I think I've got this backwards and processors
# should be a set of 4 optional blocks named :validate, :transform,
# :match, and :restore. Having to use a singleton here is a huge
# code smell.
processor = Object.new
class <<processor
attr_accessor :block
def transform(name, value)
block.call(name, value)
end
end
processor.block = options[:parameterize]
else
processor = nil
end
result = self.expand(merged, processor)
result.to_s if result
end | ruby | {
"resource": ""
} |
q12832 | Addressable.Template.transform_partial_capture | train | def transform_partial_capture(mapping, capture, processor = nil,
normalize_values = true)
_, operator, varlist = *capture.match(EXPRESSION)
vars = varlist.split(",")
if operator == "?"
# partial expansion of form style query variables sometimes requires a
# slight reordering of the variables to produce a valid url.
first_to_expand = vars.find { |varspec|
_, name, _ = *varspec.match(VARSPEC)
mapping.key?(name) && !mapping[name].nil?
}
vars = [first_to_expand] + vars.reject {|varspec| varspec == first_to_expand} if first_to_expand
end
vars.
inject("".dup) do |acc, varspec|
_, name, _ = *varspec.match(VARSPEC)
next_val = if mapping.key? name
transform_capture(mapping, "{#{operator}#{varspec}}",
processor, normalize_values)
else
"{#{operator}#{varspec}}"
end
# If we've already expanded at least one '?' operator with non-empty
# value, change to '&'
operator = "&" if (operator == "?") && (next_val != "")
acc << next_val
end
end | ruby | {
"resource": ""
} |
q12833 | Addressable.Template.normalize_keys | train | def normalize_keys(mapping)
return mapping.inject({}) do |accu, pair|
name, value = pair
if Symbol === name
name = name.to_s
elsif name.respond_to?(:to_str)
name = name.to_str
else
raise TypeError,
"Can't convert #{name.class} into String."
end
accu[name] = value
accu
end
end | ruby | {
"resource": ""
} |
q12834 | Addressable.URI.freeze | train | def freeze
self.normalized_scheme
self.normalized_user
self.normalized_password
self.normalized_userinfo
self.normalized_host
self.normalized_port
self.normalized_authority
self.normalized_site
self.normalized_path
self.normalized_query
self.normalized_fragment
self.hash
super
end | ruby | {
"resource": ""
} |
q12835 | Addressable.URI.normalized_scheme | train | def normalized_scheme
return nil unless self.scheme
@normalized_scheme ||= begin
if self.scheme =~ /^\s*ssh\+svn\s*$/i
"svn+ssh".dup
else
Addressable::URI.normalize_component(
self.scheme.strip.downcase,
Addressable::URI::CharacterClasses::SCHEME
)
end
end
# All normalized values should be UTF-8
@normalized_scheme.force_encoding(Encoding::UTF_8) if @normalized_scheme
@normalized_scheme
end | ruby | {
"resource": ""
} |
q12836 | Addressable.URI.scheme= | train | def scheme=(new_scheme)
if new_scheme && !new_scheme.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_scheme.class} into String."
elsif new_scheme
new_scheme = new_scheme.to_str
end
if new_scheme && new_scheme !~ /\A[a-z][a-z0-9\.\+\-]*\z/i
raise InvalidURIError, "Invalid scheme format: #{new_scheme}"
end
@scheme = new_scheme
@scheme = nil if @scheme.to_s.strip.empty?
# Reset dependent values
remove_instance_variable(:@normalized_scheme) if defined?(@normalized_scheme)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12837 | Addressable.URI.user= | train | def user=(new_user)
if new_user && !new_user.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_user.class} into String."
end
@user = new_user ? new_user.to_str : nil
# You can't have a nil user with a non-nil password
if password != nil
@user = EMPTY_STR if @user.nil?
end
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_user) if defined?(@normalized_user)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12838 | Addressable.URI.normalized_password | train | def normalized_password
return nil unless self.password
return @normalized_password if defined?(@normalized_password)
@normalized_password ||= begin
if self.normalized_scheme =~ /https?/ && self.password.strip.empty? &&
(!self.user || self.user.strip.empty?)
nil
else
Addressable::URI.normalize_component(
self.password.strip,
Addressable::URI::CharacterClasses::UNRESERVED
)
end
end
# All normalized values should be UTF-8
if @normalized_password
@normalized_password.force_encoding(Encoding::UTF_8)
end
@normalized_password
end | ruby | {
"resource": ""
} |
q12839 | Addressable.URI.password= | train | def password=(new_password)
if new_password && !new_password.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_password.class} into String."
end
@password = new_password ? new_password.to_str : nil
# You can't have a nil user with a non-nil password
@password ||= nil
@user ||= nil
if @password != nil
@user = EMPTY_STR if @user.nil?
end
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_password) if defined?(@normalized_password)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12840 | Addressable.URI.userinfo | train | def userinfo
current_user = self.user
current_password = self.password
(current_user || current_password) && @userinfo ||= begin
if current_user && current_password
"#{current_user}:#{current_password}"
elsif current_user && !current_password
"#{current_user}"
end
end
end | ruby | {
"resource": ""
} |
q12841 | Addressable.URI.normalized_userinfo | train | def normalized_userinfo
return nil unless self.userinfo
return @normalized_userinfo if defined?(@normalized_userinfo)
@normalized_userinfo ||= begin
current_user = self.normalized_user
current_password = self.normalized_password
if !current_user && !current_password
nil
elsif current_user && current_password
"#{current_user}:#{current_password}".dup
elsif current_user && !current_password
"#{current_user}".dup
end
end
# All normalized values should be UTF-8
if @normalized_userinfo
@normalized_userinfo.force_encoding(Encoding::UTF_8)
end
@normalized_userinfo
end | ruby | {
"resource": ""
} |
q12842 | Addressable.URI.userinfo= | train | def userinfo=(new_userinfo)
if new_userinfo && !new_userinfo.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_userinfo.class} into String."
end
new_user, new_password = if new_userinfo
[
new_userinfo.to_str.strip[/^(.*):/, 1],
new_userinfo.to_str.strip[/:(.*)$/, 1]
]
else
[nil, nil]
end
# Password assigned first to ensure validity in case of nil
self.password = new_password
self.user = new_user
# Reset dependent values
remove_instance_variable(:@authority) if defined?(@authority)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12843 | Addressable.URI.normalized_host | train | def normalized_host
return nil unless self.host
@normalized_host ||= begin
if !self.host.strip.empty?
result = ::Addressable::IDNA.to_ascii(
URI.unencode_component(self.host.strip.downcase)
)
if result =~ /[^\.]\.$/
# Single trailing dots are unnecessary.
result = result[0...-1]
end
result = Addressable::URI.normalize_component(
result,
CharacterClasses::HOST)
result
else
EMPTY_STR.dup
end
end
# All normalized values should be UTF-8
@normalized_host.force_encoding(Encoding::UTF_8) if @normalized_host
@normalized_host
end | ruby | {
"resource": ""
} |
q12844 | Addressable.URI.host= | train | def host=(new_host)
if new_host && !new_host.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_host.class} into String."
end
@host = new_host ? new_host.to_str : nil
# Reset dependent values
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_host) if defined?(@normalized_host)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12845 | Addressable.URI.authority | train | def authority
self.host && @authority ||= begin
authority = String.new
if self.userinfo != nil
authority << "#{self.userinfo}@"
end
authority << self.host
if self.port != nil
authority << ":#{self.port}"
end
authority
end
end | ruby | {
"resource": ""
} |
q12846 | Addressable.URI.normalized_authority | train | def normalized_authority
return nil unless self.authority
@normalized_authority ||= begin
authority = String.new
if self.normalized_userinfo != nil
authority << "#{self.normalized_userinfo}@"
end
authority << self.normalized_host
if self.normalized_port != nil
authority << ":#{self.normalized_port}"
end
authority
end
# All normalized values should be UTF-8
if @normalized_authority
@normalized_authority.force_encoding(Encoding::UTF_8)
end
@normalized_authority
end | ruby | {
"resource": ""
} |
q12847 | Addressable.URI.authority= | train | def authority=(new_authority)
if new_authority
if !new_authority.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_authority.class} into String."
end
new_authority = new_authority.to_str
new_userinfo = new_authority[/^([^\[\]]*)@/, 1]
if new_userinfo
new_user = new_userinfo.strip[/^([^:]*):?/, 1]
new_password = new_userinfo.strip[/:(.*)$/, 1]
end
new_host = new_authority.sub(
/^([^\[\]]*)@/, EMPTY_STR
).sub(
/:([^:@\[\]]*?)$/, EMPTY_STR
)
new_port =
new_authority[/:([^:@\[\]]*?)$/, 1]
end
# Password assigned first to ensure validity in case of nil
self.password = defined?(new_password) ? new_password : nil
self.user = defined?(new_user) ? new_user : nil
self.host = defined?(new_host) ? new_host : nil
self.port = defined?(new_port) ? new_port : nil
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12848 | Addressable.URI.origin= | train | def origin=(new_origin)
if new_origin
if !new_origin.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_origin.class} into String."
end
new_origin = new_origin.to_str
new_scheme = new_origin[/^([^:\/?#]+):\/\//, 1]
unless new_scheme
raise InvalidURIError, 'An origin cannot omit the scheme.'
end
new_host = new_origin[/:\/\/([^\/?#:]+)/, 1]
unless new_host
raise InvalidURIError, 'An origin cannot omit the host.'
end
new_port = new_origin[/:([^:@\[\]\/]*?)$/, 1]
end
self.scheme = defined?(new_scheme) ? new_scheme : nil
self.host = defined?(new_host) ? new_host : nil
self.port = defined?(new_port) ? new_port : nil
self.userinfo = nil
# Reset dependent values
remove_instance_variable(:@userinfo) if defined?(@userinfo)
remove_instance_variable(:@normalized_userinfo) if defined?(@normalized_userinfo)
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_authority) if defined?(@normalized_authority)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12849 | Addressable.URI.port= | train | def port=(new_port)
if new_port != nil && new_port.respond_to?(:to_str)
new_port = Addressable::URI.unencode_component(new_port.to_str)
end
if new_port.respond_to?(:valid_encoding?) && !new_port.valid_encoding?
raise InvalidURIError, "Invalid encoding in port"
end
if new_port != nil && !(new_port.to_s =~ /^\d+$/)
raise InvalidURIError,
"Invalid port number: #{new_port.inspect}"
end
@port = new_port.to_s.to_i
@port = nil if @port == 0
# Reset dependent values
remove_instance_variable(:@authority) if defined?(@authority)
remove_instance_variable(:@normalized_port) if defined?(@normalized_port)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12850 | Addressable.URI.site | train | def site
(self.scheme || self.authority) && @site ||= begin
site_string = "".dup
site_string << "#{self.scheme}:" if self.scheme != nil
site_string << "//#{self.authority}" if self.authority != nil
site_string
end
end | ruby | {
"resource": ""
} |
q12851 | Addressable.URI.normalized_site | train | def normalized_site
return nil unless self.site
@normalized_site ||= begin
site_string = "".dup
if self.normalized_scheme != nil
site_string << "#{self.normalized_scheme}:"
end
if self.normalized_authority != nil
site_string << "//#{self.normalized_authority}"
end
site_string
end
# All normalized values should be UTF-8
@normalized_site.force_encoding(Encoding::UTF_8) if @normalized_site
@normalized_site
end | ruby | {
"resource": ""
} |
q12852 | Addressable.URI.site= | train | def site=(new_site)
if new_site
if !new_site.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_site.class} into String."
end
new_site = new_site.to_str
# These two regular expressions derived from the primary parsing
# expression
self.scheme = new_site[/^(?:([^:\/?#]+):)?(?:\/\/(?:[^\/?#]*))?$/, 1]
self.authority = new_site[
/^(?:(?:[^:\/?#]+):)?(?:\/\/([^\/?#]*))?$/, 1
]
else
self.scheme = nil
self.authority = nil
end
end | ruby | {
"resource": ""
} |
q12853 | Addressable.URI.normalized_path | train | def normalized_path
@normalized_path ||= begin
path = self.path.to_s
if self.scheme == nil && path =~ NORMPATH
# Relative paths with colons in the first segment are ambiguous.
path = path.sub(":", "%2F")
end
# String#split(delimeter, -1) uses the more strict splitting behavior
# found by default in Python.
result = path.strip.split(SLASH, -1).map do |segment|
Addressable::URI.normalize_component(
segment,
Addressable::URI::CharacterClasses::PCHAR
)
end.join(SLASH)
result = URI.normalize_path(result)
if result.empty? &&
["http", "https", "ftp", "tftp"].include?(self.normalized_scheme)
result = SLASH.dup
end
result
end
# All normalized values should be UTF-8
@normalized_path.force_encoding(Encoding::UTF_8) if @normalized_path
@normalized_path
end | ruby | {
"resource": ""
} |
q12854 | Addressable.URI.path= | train | def path=(new_path)
if new_path && !new_path.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_path.class} into String."
end
@path = (new_path || EMPTY_STR).to_str
if !@path.empty? && @path[0..0] != SLASH && host != nil
@path = "/#{@path}"
end
# Reset dependent values
remove_instance_variable(:@normalized_path) if defined?(@normalized_path)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12855 | Addressable.URI.normalized_query | train | def normalized_query(*flags)
return nil unless self.query
return @normalized_query if defined?(@normalized_query)
@normalized_query ||= begin
modified_query_class = Addressable::URI::CharacterClasses::QUERY.dup
# Make sure possible key-value pair delimiters are escaped.
modified_query_class.sub!("\\&", "").sub!("\\;", "")
pairs = (self.query || "").split("&", -1)
pairs.sort! if flags.include?(:sorted)
component = pairs.map do |pair|
Addressable::URI.normalize_component(pair, modified_query_class, "+")
end.join("&")
component == "" ? nil : component
end
# All normalized values should be UTF-8
@normalized_query.force_encoding(Encoding::UTF_8) if @normalized_query
@normalized_query
end | ruby | {
"resource": ""
} |
q12856 | Addressable.URI.query= | train | def query=(new_query)
if new_query && !new_query.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_query.class} into String."
end
@query = new_query ? new_query.to_str : nil
# Reset dependent values
remove_instance_variable(:@normalized_query) if defined?(@normalized_query)
remove_composite_values
end | ruby | {
"resource": ""
} |
q12857 | Addressable.URI.query_values | train | def query_values(return_type=Hash)
empty_accumulator = Array == return_type ? [] : {}
if return_type != Hash && return_type != Array
raise ArgumentError, "Invalid return type. Must be Hash or Array."
end
return nil if self.query == nil
split_query = self.query.split("&").map do |pair|
pair.split("=", 2) if pair && !pair.empty?
end.compact
return split_query.inject(empty_accumulator.dup) do |accu, pair|
# I'd rather use key/value identifiers instead of array lookups,
# but in this case I really want to maintain the exact pair structure,
# so it's best to make all changes in-place.
pair[0] = URI.unencode_component(pair[0])
if pair[1].respond_to?(:to_str)
# I loathe the fact that I have to do this. Stupid HTML 4.01.
# Treating '+' as a space was just an unbelievably bad idea.
# There was nothing wrong with '%20'!
# If it ain't broke, don't fix it!
pair[1] = URI.unencode_component(pair[1].to_str.gsub(/\+/, " "))
end
if return_type == Hash
accu[pair[0]] = pair[1]
else
accu << pair
end
accu
end
end | ruby | {
"resource": ""
} |
q12858 | Addressable.URI.query_values= | train | def query_values=(new_query_values)
if new_query_values == nil
self.query = nil
return nil
end
if !new_query_values.is_a?(Array)
if !new_query_values.respond_to?(:to_hash)
raise TypeError,
"Can't convert #{new_query_values.class} into Hash."
end
new_query_values = new_query_values.to_hash
new_query_values = new_query_values.map do |key, value|
key = key.to_s if key.kind_of?(Symbol)
[key, value]
end
# Useful default for OAuth and caching.
# Only to be used for non-Array inputs. Arrays should preserve order.
new_query_values.sort!
end
# new_query_values have form [['key1', 'value1'], ['key2', 'value2']]
buffer = "".dup
new_query_values.each do |key, value|
encoded_key = URI.encode_component(
key, CharacterClasses::UNRESERVED
)
if value == nil
buffer << "#{encoded_key}&"
elsif value.kind_of?(Array)
value.each do |sub_value|
encoded_value = URI.encode_component(
sub_value, CharacterClasses::UNRESERVED
)
buffer << "#{encoded_key}=#{encoded_value}&"
end
else
encoded_value = URI.encode_component(
value, CharacterClasses::UNRESERVED
)
buffer << "#{encoded_key}=#{encoded_value}&"
end
end
self.query = buffer.chop
end | ruby | {
"resource": ""
} |
q12859 | Addressable.URI.request_uri= | train | def request_uri=(new_request_uri)
if !new_request_uri.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_request_uri.class} into String."
end
if self.absolute? && self.scheme !~ /^https?$/i
raise InvalidURIError,
"Cannot set an HTTP request URI for a non-HTTP URI."
end
new_request_uri = new_request_uri.to_str
path_component = new_request_uri[/^([^\?]*)\??(?:.*)$/, 1]
query_component = new_request_uri[/^(?:[^\?]*)\?(.*)$/, 1]
path_component = path_component.to_s
path_component = (!path_component.empty? ? path_component : SLASH)
self.path = path_component
self.query = query_component
# Reset dependent values
remove_composite_values
end | ruby | {
"resource": ""
} |
q12860 | Addressable.URI.normalized_fragment | train | def normalized_fragment
return nil unless self.fragment
return @normalized_fragment if defined?(@normalized_fragment)
@normalized_fragment ||= begin
component = Addressable::URI.normalize_component(
self.fragment,
Addressable::URI::CharacterClasses::FRAGMENT
)
component == "" ? nil : component
end
# All normalized values should be UTF-8
if @normalized_fragment
@normalized_fragment.force_encoding(Encoding::UTF_8)
end
@normalized_fragment
end | ruby | {
"resource": ""
} |
q12861 | Addressable.URI.fragment= | train | def fragment=(new_fragment)
if new_fragment && !new_fragment.respond_to?(:to_str)
raise TypeError, "Can't convert #{new_fragment.class} into String."
end
@fragment = new_fragment ? new_fragment.to_str : nil
# Reset dependent values
remove_instance_variable(:@normalized_fragment) if defined?(@normalized_fragment)
remove_composite_values
# Ensure we haven't created an invalid URI
validate()
end | ruby | {
"resource": ""
} |
q12862 | Addressable.URI.join | train | def join(uri)
if !uri.respond_to?(:to_str)
raise TypeError, "Can't convert #{uri.class} into String."
end
if !uri.kind_of?(URI)
# Otherwise, convert to a String, then parse.
uri = URI.parse(uri.to_str)
end
if uri.to_s.empty?
return self.dup
end
joined_scheme = nil
joined_user = nil
joined_password = nil
joined_host = nil
joined_port = nil
joined_path = nil
joined_query = nil
joined_fragment = nil
# Section 5.2.2 of RFC 3986
if uri.scheme != nil
joined_scheme = uri.scheme
joined_user = uri.user
joined_password = uri.password
joined_host = uri.host
joined_port = uri.port
joined_path = URI.normalize_path(uri.path)
joined_query = uri.query
else
if uri.authority != nil
joined_user = uri.user
joined_password = uri.password
joined_host = uri.host
joined_port = uri.port
joined_path = URI.normalize_path(uri.path)
joined_query = uri.query
else
if uri.path == nil || uri.path.empty?
joined_path = self.path
if uri.query != nil
joined_query = uri.query
else
joined_query = self.query
end
else
if uri.path[0..0] == SLASH
joined_path = URI.normalize_path(uri.path)
else
base_path = self.path.dup
base_path = EMPTY_STR if base_path == nil
base_path = URI.normalize_path(base_path)
# Section 5.2.3 of RFC 3986
#
# Removes the right-most path segment from the base path.
if base_path =~ /\//
base_path.sub!(/\/[^\/]+$/, SLASH)
else
base_path = EMPTY_STR
end
# If the base path is empty and an authority segment has been
# defined, use a base path of SLASH
if base_path.empty? && self.authority != nil
base_path = SLASH
end
joined_path = URI.normalize_path(base_path + uri.path)
end
joined_query = uri.query
end
joined_user = self.user
joined_password = self.password
joined_host = self.host
joined_port = self.port
end
joined_scheme = self.scheme
end
joined_fragment = uri.fragment
return self.class.new(
:scheme => joined_scheme,
:user => joined_user,
:password => joined_password,
:host => joined_host,
:port => joined_port,
:path => joined_path,
:query => joined_query,
:fragment => joined_fragment
)
end | ruby | {
"resource": ""
} |
q12863 | Addressable.URI.normalize | train | def normalize
# This is a special exception for the frequently misused feed
# URI scheme.
if normalized_scheme == "feed"
if self.to_s =~ /^feed:\/*http:\/*/
return URI.parse(
self.to_s[/^feed:\/*(http:\/*.*)/, 1]
).normalize
end
end
return self.class.new(
:scheme => normalized_scheme,
:authority => normalized_authority,
:path => normalized_path,
:query => normalized_query,
:fragment => normalized_fragment
)
end | ruby | {
"resource": ""
} |
q12864 | Addressable.URI.defer_validation | train | def defer_validation(&block)
raise LocalJumpError, "No block given." unless block
@validation_deferred = true
block.call()
@validation_deferred = false
validate
return nil
end | ruby | {
"resource": ""
} |
q12865 | Addressable.URI.validate | train | def validate
return if !!@validation_deferred
if self.scheme != nil && self.ip_based? &&
(self.host == nil || self.host.empty?) &&
(self.path == nil || self.path.empty?)
raise InvalidURIError,
"Absolute URI missing hierarchical segment: '#{self.to_s}'"
end
if self.host == nil
if self.port != nil ||
self.user != nil ||
self.password != nil
raise InvalidURIError, "Hostname not supplied: '#{self.to_s}'"
end
end
if self.path != nil && !self.path.empty? && self.path[0..0] != SLASH &&
self.authority != nil
raise InvalidURIError,
"Cannot have a relative path with an authority set: '#{self.to_s}'"
end
if self.path != nil && !self.path.empty? &&
self.path[0..1] == SLASH + SLASH && self.authority == nil
raise InvalidURIError,
"Cannot have a path with two leading slashes " +
"without an authority set: '#{self.to_s}'"
end
unreserved = CharacterClasses::UNRESERVED
sub_delims = CharacterClasses::SUB_DELIMS
if !self.host.nil? && (self.host =~ /[<>{}\/\\\?\#\@"[[:space:]]]/ ||
(self.host[/^\[(.*)\]$/, 1] != nil && self.host[/^\[(.*)\]$/, 1] !~
Regexp.new("^[#{unreserved}#{sub_delims}:]*$")))
raise InvalidURIError, "Invalid character in host: '#{self.host.to_s}'"
end
return nil
end | ruby | {
"resource": ""
} |
q12866 | Addressable.URI.replace_self | train | def replace_self(uri)
# Reset dependent values
instance_variables.each do |var|
if instance_variable_defined?(var) && var != :@validation_deferred
remove_instance_variable(var)
end
end
@scheme = uri.scheme
@user = uri.user
@password = uri.password
@host = uri.host
@port = uri.port
@path = uri.path
@query = uri.query
@fragment = uri.fragment
return self
end | ruby | {
"resource": ""
} |
q12867 | Dynamoid.Fields.write_attribute | train | def write_attribute(name, value)
name = name.to_sym
if association = @associations[name]
association.reset
end
@attributes_before_type_cast[name] = value
value_casted = TypeCasting.cast_field(value, self.class.attributes[name])
attributes[name] = value_casted
end | ruby | {
"resource": ""
} |
q12868 | Dynamoid.Fields.set_created_at | train | def set_created_at
self.created_at ||= DateTime.now.in_time_zone(Time.zone) if Dynamoid::Config.timestamps
end | ruby | {
"resource": ""
} |
q12869 | Dynamoid.Fields.set_updated_at | train | def set_updated_at
if Dynamoid::Config.timestamps && !updated_at_changed?
self.updated_at = DateTime.now.in_time_zone(Time.zone)
end
end | ruby | {
"resource": ""
} |
q12870 | Dynamoid.Document.reload | train | def reload
options = { consistent_read: true }
if self.class.range_key
options[:range_key] = range_value
end
self.attributes = self.class.find(hash_key, options).attributes
@associations.values.each(&:reset)
self
end | ruby | {
"resource": ""
} |
q12871 | Dynamoid.Document.evaluate_default_value | train | def evaluate_default_value(val)
if val.respond_to?(:call)
val.call
elsif val.duplicable?
val.dup
else
val
end
end | ruby | {
"resource": ""
} |
q12872 | Dynamoid.Persistence.touch | train | def touch(name = nil)
now = DateTime.now
self.updated_at = now
attributes[name] = now if name
save
end | ruby | {
"resource": ""
} |
q12873 | Dynamoid.Persistence.save | train | def save(_options = {})
self.class.create_table
if new_record?
conditions = { unless_exists: [self.class.hash_key] }
conditions[:unless_exists] << range_key if range_key
run_callbacks(:create) { persist(conditions) }
else
persist
end
end | ruby | {
"resource": ""
} |
q12874 | Dynamoid.Persistence.update_attributes | train | def update_attributes(attributes)
attributes.each { |attribute, value| write_attribute(attribute, value) }
save
end | ruby | {
"resource": ""
} |
q12875 | Dynamoid.Persistence.delete | train | def delete
options = range_key ? { range_key: Dumping.dump_field(read_attribute(range_key), self.class.attributes[range_key]) } : {}
# Add an optimistic locking check if the lock_version column exists
if self.class.attributes[:lock_version]
conditions = { if: {} }
conditions[:if][:lock_version] =
if changes[:lock_version].nil?
lock_version
else
changes[:lock_version][0]
end
options[:conditions] = conditions
end
Dynamoid.adapter.delete(self.class.table_name, hash_key, options)
rescue Dynamoid::Errors::ConditionalCheckFailedException
raise Dynamoid::Errors::StaleObjectError.new(self, 'delete')
end | ruby | {
"resource": ""
} |
q12876 | Dynamoid.Persistence.persist | train | def persist(conditions = nil)
run_callbacks(:save) do
self.hash_key = SecureRandom.uuid if hash_key.blank?
# Add an exists check to prevent overwriting existing records with new ones
if new_record?
conditions ||= {}
(conditions[:unless_exists] ||= []) << self.class.hash_key
end
# Add an optimistic locking check if the lock_version column exists
if self.class.attributes[:lock_version]
conditions ||= {}
self.lock_version = (lock_version || 0) + 1
# Uses the original lock_version value from ActiveModel::Dirty in case user changed lock_version manually
(conditions[:if] ||= {})[:lock_version] = changes[:lock_version][0] if changes[:lock_version][0]
end
attributes_dumped = Dumping.dump_attributes(attributes, self.class.attributes)
begin
Dynamoid.adapter.write(self.class.table_name, attributes_dumped, conditions)
@new_record = false
true
rescue Dynamoid::Errors::ConditionalCheckFailedException => e
if new_record?
raise Dynamoid::Errors::RecordNotUnique.new(e, self)
else
raise Dynamoid::Errors::StaleObjectError.new(self, 'persist')
end
end
end
end | ruby | {
"resource": ""
} |
q12877 | Dynamoid.Adapter.adapter | train | def adapter
unless @adapter_.value
adapter = self.class.adapter_plugin_class.new
adapter.connect! if adapter.respond_to?(:connect!)
@adapter_.compare_and_set(nil, adapter)
clear_cache!
end
@adapter_.value
end | ruby | {
"resource": ""
} |
q12878 | Dynamoid.Adapter.benchmark | train | def benchmark(method, *args)
start = Time.now
result = yield
Dynamoid.logger.debug "(#{((Time.now - start) * 1000.0).round(2)} ms) #{method.to_s.split('_').collect(&:upcase).join(' ')}#{" - #{args.inspect}" unless args.nil? || args.empty?}"
result
end | ruby | {
"resource": ""
} |
q12879 | Dynamoid.Adapter.read | train | def read(table, ids, options = {}, &blk)
if ids.respond_to?(:each)
batch_get_item({ table => ids }, options, &blk)
else
get_item(table, ids, options)
end
end | ruby | {
"resource": ""
} |
q12880 | Dynamoid.Adapter.delete | train | def delete(table, ids, options = {})
range_key = options[:range_key] # array of range keys that matches the ids passed in
if ids.respond_to?(:each)
ids = if range_key.respond_to?(:each)
# turn ids into array of arrays each element being hash_key, range_key
ids.each_with_index.map { |id, i| [id, range_key[i]] }
else
range_key ? ids.map { |id| [id, range_key] } : ids
end
batch_delete_item(table => ids)
else
delete_item(table, ids, options)
end
end | ruby | {
"resource": ""
} |
q12881 | Dynamoid.Adapter.scan | train | def scan(table, query = {}, opts = {})
benchmark('Scan', table, query) { adapter.scan(table, query, opts) }
end | ruby | {
"resource": ""
} |
q12882 | Dynamoid.Adapter.method_missing | train | def method_missing(method, *args, &block)
return benchmark(method, *args) { adapter.send(method, *args, &block) } if adapter.respond_to?(method)
super
end | ruby | {
"resource": ""
} |
q12883 | Dynamoid.Config.logger= | train | def logger=(logger)
case logger
when false, nil then @logger = NullLogger.new
when true then @logger = default_logger
else
@logger = logger if logger.respond_to?(:info)
end
end | ruby | {
"resource": ""
} |
q12884 | CombinePDF.Renderer.object_to_pdf | train | def object_to_pdf(object)
if object.nil?
return 'null'
elsif object.is_a?(String)
return format_string_to_pdf object
elsif object.is_a?(Symbol)
return format_name_to_pdf object
elsif object.is_a?(Array)
return format_array_to_pdf object
elsif object.is_a?(Integer) || object.is_a?(TrueClass) || object.is_a?(FalseClass)
return object.to_s
elsif object.is_a?(Numeric) # Float or other non-integer
return sprintf('%f', object)
elsif object.is_a?(Hash)
return format_hash_to_pdf object
else
return ''
end
end | ruby | {
"resource": ""
} |
q12885 | CombinePDF.PDF.new_page | train | def new_page(mediabox = [0, 0, 612.0, 792.0], _location = -1)
p = PDFWriter.new(mediabox)
insert(-1, p)
p
end | ruby | {
"resource": ""
} |
q12886 | CombinePDF.PDF.to_pdf | train | def to_pdf(options = {})
# reset version if not specified
@version = 1.5 if @version.to_f == 0.0
# set info for merged file
@info[:ModDate] = @info[:CreationDate] = Time.now.strftime "D:%Y%m%d%H%M%S%:::z'00"
@info[:Subject] = options[:subject] if options[:subject]
@info[:Producer] = options[:producer] if options[:producer]
# rebuild_catalog
catalog = rebuild_catalog_and_objects
# add ID and generation numbers to objects
renumber_object_ids
out = []
xref = []
indirect_object_count = 1 # the first object is the null object
# write head (version and binanry-code)
out << "%PDF-#{@version}\n%\xFF\xFF\xFF\xFF\xFF\x00\x00\x00\x00".force_encoding(Encoding::ASCII_8BIT)
# collect objects and set xref table locations
loc = 0
out.each { |line| loc += line.bytesize + 1 }
@objects.each do |o|
indirect_object_count += 1
xref << loc
out << object_to_pdf(o)
loc += out.last.bytesize + 1
end
xref_location = loc
# xref_location = 0
# out.each { |line| xref_location += line.bytesize + 1}
out << "xref\n0 #{indirect_object_count}\n0000000000 65535 f \n"
xref.each { |offset| out << (out.pop + ("%010d 00000 n \n" % offset)) }
out << out.pop + 'trailer'
out << "<<\n/Root #{false || "#{catalog[:indirect_reference_id]} #{catalog[:indirect_generation_number]} R"}"
out << "/Size #{indirect_object_count}"
out << "/Info #{@info[:indirect_reference_id]} #{@info[:indirect_generation_number]} R"
out << ">>\nstartxref\n#{xref_location}\n%%EOF"
# when finished, remove the numbering system and keep only pointers
remove_old_ids
# output the pdf stream
out.join("\n".force_encoding(Encoding::ASCII_8BIT)).force_encoding(Encoding::ASCII_8BIT)
end | ruby | {
"resource": ""
} |
q12887 | CombinePDF.PDF.pages | train | def pages(catalogs = nil)
page_list = []
catalogs ||= get_existing_catalogs
if catalogs.is_a?(Array)
catalogs.each { |c| page_list.concat pages(c) unless c.nil? }
elsif catalogs.is_a?(Hash)
if catalogs[:is_reference_only]
if catalogs[:referenced_object]
page_list.concat pages(catalogs[:referenced_object])
else
warn "couldn't follow reference!!! #{catalogs} not found!"
end
else
case catalogs[:Type]
when :Page
page_list << catalogs
when :Pages
page_list.concat pages(catalogs[:Kids]) unless catalogs[:Kids].nil?
when :Catalog
page_list.concat pages(catalogs[:Pages]) unless catalogs[:Pages].nil?
end
end
end
page_list
end | ruby | {
"resource": ""
} |
q12888 | CombinePDF.PDF.fonts | train | def fonts(limit_to_type0 = false)
fonts_array = []
pages.each do |pg|
if pg[:Resources][:Font]
pg[:Resources][:Font].values.each do |f|
f = f[:referenced_object] if f[:referenced_object]
if (limit_to_type0 || f[:Subtype] == :Type0) && f[:Type] == :Font && !fonts_array.include?(f)
fonts_array << f
end
end
end
end
fonts_array
end | ruby | {
"resource": ""
} |
q12889 | CombinePDF.PDF.remove | train | def remove(page_index)
catalog = rebuild_catalog
pages_array = catalog[:Pages][:referenced_object][:Kids]
removed_page = pages_array.delete_at page_index
catalog[:Pages][:referenced_object][:Count] = pages_array.length
removed_page
end | ruby | {
"resource": ""
} |
q12890 | CombinePDF.Fonts.register_font_from_pdf_object | train | def register_font_from_pdf_object(font_name, font_object)
# FIXME:
# - add stream deflation for the CMap file.
# - add :Encoding CMaps (such as :WinAnsiEncoding etc`)
# - the ToUnicode CMap parsing assumes 8 Bytes <0F0F> while 16 Bytes and multiple unicode chars are also possible.
# first, create cmap, as it will be used to correctly create the widths directory.
# find the CMap from one of the two systems (TrueType vs. Type0 fonts)
# at the moment doen't suppot :Encoding cmaps...
cmap = {}
if font_object[:ToUnicode]
to_unicode = font_object[:ToUnicode]
to_unicode = to_unicode[:referenced_object] if to_unicode[:is_reference_only]
# deflate the cmap file stream before parsing
to_unicode = create_deep_copy to_unicode
CombinePDF::PDFFilter.inflate_object to_unicode
# parse the deflated stream
cmap = parse_cmap to_unicode[:raw_stream_content]
else
warn "didn't find ToUnicode object for #{font_object}"
return false
end
# second, create the metrics directory.
metrics = {}
old_widths = font_object
if font_object[:DescendantFonts]
old_widths = font_object[:DescendantFonts]
old_widths = old_widths[:referenced_object][:indirect_without_dictionary] if old_widths.is_a?(Hash) && old_widths[:is_reference_only]
old_widths = old_widths[0][:referenced_object]
avrg_height = 360
avrg_height = old_widths[:XHeight] if old_widths[:XHeight]
avrg_height = (avrg_height + old_widths[:CapHeight]) / 2 if old_widths[:CapHeight]
avrg_width = old_widths[:AvgWidth] || 0
avarage_bbox = [0, 0, avrg_width, avrg_height] # data is missing for full box metrics, just ignore
end
# compute the metrics values using the appropiate system (TrueType vs. Type0 fonts)
cmap_inverted = {}
cmap.each { |k, v| cmap_inverted[v.hex] = k }
if old_widths[:W]
old_widths = old_widths[:W]
if old_widths.is_a?(Hash) && old_widths[:is_reference_only]
old_widths = old_widths[:referenced_object][:indirect_without_dictionary]
end
old_widths = create_deep_copy old_widths
while old_widths[0]
a = old_widths.shift
b = old_widths.shift
if b.is_a?(Array)
b.each_index { |i| metrics[cmap_inverted[(a + i)] || (a + i)] = { wx: b[i], boundingbox: avarage_bbox } }
else
c = old_widths.shift
(b - a).times { |i| metrics[cmap_inverted[(a + i)] || (a + i)] = { wx: c[0], boundingbox: avarage_bbox } }
end
end
elsif old_widths[:Widths]
first_char = old_widths[:FirstChar]
old_widths = old_widths[:Widths]
if old_widths.is_a?(Hash) && old_widths[:is_reference_only]
old_widths = old_widths[:referenced_object][:indirect_without_dictionary]
end
old_widths.each_index { |i| metrics[cmap_inverted[(i + first_char)] || (i + first_char)] = { wx: old_widths[i], boundingbox: avarage_bbox } }
else
warn "didn't find widths object for #{old_widths}"
return false
end
# register the font and return the font object
cmap = nil if cmap.empty?
CombinePDF::Fonts.register_font font_name, metrics, font_object, cmap
end | ruby | {
"resource": ""
} |
q12891 | CombinePDF.Page_Methods.init_contents | train | def init_contents
self[:Contents] = self[:Contents][:referenced_object][:indirect_without_dictionary] if self[:Contents].is_a?(Hash) && self[:Contents][:referenced_object] && self[:Contents][:referenced_object].is_a?(Hash) && self[:Contents][:referenced_object][:indirect_without_dictionary]
self[:Contents] = [self[:Contents]] unless self[:Contents].is_a?(Array)
self[:Contents].delete(is_reference_only: true, referenced_object: { indirect_reference_id: 0, raw_stream_content: '' })
# un-nest any referenced arrays
self[:Contents].map! { |s| actual_value(s).is_a?(Array) ? actual_value(s) : s }
self[:Contents].flatten!
self[:Contents].compact!
# wrap content streams
insert_content 'q', 0
insert_content 'Q'
# Prep content
@contents = ''
insert_content @contents
@contents
end | ruby | {
"resource": ""
} |
q12892 | CombinePDF.Page_Methods.insert_content | train | def insert_content(object, location = -1)
object = { is_reference_only: true, referenced_object: { indirect_reference_id: 0, raw_stream_content: object } } if object.is_a?(String)
raise TypeError, 'expected a String or Hash object.' unless object.is_a?(Hash)
prep_content_array
self[:Contents].insert location, object
self[:Contents].flatten!
self
end | ruby | {
"resource": ""
} |
q12893 | CombinePDF.Page_Methods.graphic_state | train | def graphic_state(graphic_state_dictionary = {})
# if the graphic state exists, return it's name
resources[:ExtGState] ||= {}
gs_res = resources[:ExtGState][:referenced_object] || resources[:ExtGState]
gs_res.each do |k, v|
return k if v.is_a?(Hash) && v == graphic_state_dictionary
end
# set graphic state type
graphic_state_dictionary[:Type] = :ExtGState
# set a secure name for the graphic state
name = SecureRandom.hex(9).to_sym
# add object to reasource
gs_res[name] = graphic_state_dictionary
# return name
name
end | ruby | {
"resource": ""
} |
q12894 | Textbringer.Buffer.save_excursion | train | def save_excursion
old_point = new_mark
old_mark = @mark&.dup
old_column = @goal_column
begin
yield
ensure
point_to_mark(old_point)
old_point.delete
if old_mark
@mark.location = old_mark.location
old_mark.delete
end
@goal_column = old_column
end
end | ruby | {
"resource": ""
} |
q12895 | Textbringer.Buffer.push_mark | train | def push_mark(pos = @point)
@mark = new_mark
@mark.location = pos
@mark_ring.push(@mark)
if self != Buffer.minibuffer
global_mark_ring = Buffer.global_mark_ring
if global_mark_ring.empty? || global_mark_ring.current.buffer != self
push_global_mark(pos)
end
end
end | ruby | {
"resource": ""
} |
q12896 | Textbringer.ProgrammingMode.indent_line | train | def indent_line
result = false
level = calculate_indentation
return result if level.nil?
@buffer.save_excursion do
@buffer.beginning_of_line
@buffer.composite_edit do
if @buffer.looking_at?(/[ \t]+/)
s = @buffer.match_string(0)
break if /\t/ !~ s && s.size == level
@buffer.delete_region(@buffer.match_beginning(0),
@buffer.match_end(0))
else
break if level == 0
end
@buffer.indent_to(level)
end
result = true
end
pos = @buffer.point
@buffer.beginning_of_line
@buffer.forward_char while /[ \t]/ =~ @buffer.char_after
if @buffer.point < pos
@buffer.goto_char(pos)
end
result
end | ruby | {
"resource": ""
} |
q12897 | Wechat.Cipher.pack | train | def pack(content, app_id)
random = SecureRandom.hex(8)
text = content.force_encoding('ASCII-8BIT')
msg_len = [text.length].pack('N')
encode_padding("#{random}#{msg_len}#{text}#{app_id}")
end | ruby | {
"resource": ""
} |
q12898 | IceCube.Validations::FixedValue.validate_interval_lock | train | def validate_interval_lock(time, start_time)
t0 = starting_unit(start_time)
t1 = time.send(type)
t0 >= t1 ? t0 - t1 : INTERVALS[type] - t1 + t0
end | ruby | {
"resource": ""
} |
q12899 | IceCube.Validations::FixedValue.validate_hour_lock | train | def validate_hour_lock(time, start_time)
h0 = starting_unit(start_time)
h1 = time.hour
if h0 >= h1
h0 - h1
else
if dst_offset = TimeUtil.dst_change(time)
h0 - h1 + dst_offset
else
24 - h1 + h0
end
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.