_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5700 | StatModule.Finding.categories= | train | def categories=(categories)
raise TypeException unless categories.is_a?(Array)
categories.each { |item|
raise TypeException unless Category.all.include?(item)
raise | ruby | {
"resource": ""
} |
q5701 | StatModule.Finding.print | train | def print(formatted = false)
result = "#{rule}, #{description}"
if formatted
if failure
result = "#{FORMATTING_BALL} #{result}".colorize(:red)
else
result = "#{FORMATTING_WARNING} #{result}".colorize(:yellow)
end
end | ruby | {
"resource": ""
} |
q5702 | Wanikani.CriticalItems.critical_items | train | def critical_items(percentage = 75)
raise ArgumentError, "Percentage must be an Integer between 0 and 100" if !percentage.between?(0, 100)
| ruby | {
"resource": ""
} |
q5703 | Trepanning.Method.find_method_with_line | train | def find_method_with_line(cm, line)
unless cm.kind_of?(Rubinius::CompiledMethod)
return nil
end
lines = lines_of_method(cm)
return cm if lines.member?(line)
scope = cm.scope
return nil unless scope and scope.current_script
cm = scope.current_script.compiled_code
... | ruby | {
"resource": ""
} |
q5704 | GameOverseer.ChannelManager.register_channel | train | def register_channel(channel, service)
_channel = channel.downcase
unless @channels[_channel]
@channels[_channel] = service
GameOverseer::Console.log("ChannelManager> mapped '#{_channel}' to '#{service.class}'.")
else
| ruby | {
"resource": ""
} |
q5705 | Opencnam.Client.phone | train | def phone(phone_number, options = {})
# Build query string
options = {
:account_sid => account_sid,
:auth_token => auth_token,
:format => 'text',
}.merge(options)
options[:format] = options[:format].to_s.strip.downcase
# Check for supported format
unless %w(t... | ruby | {
"resource": ""
} |
q5706 | SpellNumber.Speller.two_digit_number | train | def two_digit_number(number, combined = false)
words = combined ? simple_number_to_words_combined(number) : simple_number_to_words(number)
return words if(words != 'not_found')
rest = number % 10 | ruby | {
"resource": ""
} |
q5707 | SpellNumber.Speller.simple_number_to_words_combined | train | def simple_number_to_words_combined(number)
words = I18n.t("spell_number.numbers.number_#{number}_combined", :locale => @options[:locale], :default => 'not_found')
| ruby | {
"resource": ""
} |
q5708 | FormAPI.PDFApi.combine_pdfs | train | def combine_pdfs(combine_pdfs_data, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5709 | FormAPI.PDFApi.combine_submissions | train | def combine_submissions(combined_submission_data, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5710 | FormAPI.PDFApi.create_custom_file_from_upload | train | def create_custom_file_from_upload(create_custom_file_data, opts = {})
data, | ruby | {
"resource": ""
} |
q5711 | FormAPI.PDFApi.create_data_request_token | train | def create_data_request_token(data_request_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5712 | FormAPI.PDFApi.create_template_from_upload | train | def create_template_from_upload(create_template_data, opts = {})
data, | ruby | {
"resource": ""
} |
q5713 | FormAPI.PDFApi.expire_combined_submission | train | def expire_combined_submission(combined_submission_id, opts = {})
data, | ruby | {
"resource": ""
} |
q5714 | FormAPI.PDFApi.expire_submission | train | def expire_submission(submission_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5715 | FormAPI.PDFApi.generate_pdf | train | def generate_pdf(template_id, submission_data, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5716 | FormAPI.PDFApi.get_data_request | train | def get_data_request(data_request_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5717 | FormAPI.PDFApi.get_submission | train | def get_submission(submission_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5718 | FormAPI.PDFApi.get_submission_batch | train | def get_submission_batch(submission_batch_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5719 | FormAPI.PDFApi.get_template | train | def get_template(template_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5720 | FormAPI.PDFApi.get_template_schema | train | def get_template_schema(template_id, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q5721 | FormAPI.PDFApi.update_data_request | train | def update_data_request(data_request_id, update_submission_data_request_data, opts = {})
data, | ruby | {
"resource": ""
} |
q5722 | ActsAsNestedInterval.InstanceMethods.next_root_lft | train | def next_root_lft
last_root = nested_interval_scope.roots.order( rgtp: :desc, rgtq: :desc ).first
raise Exception.new("Only one root allowed") if last_root.present? | ruby | {
"resource": ""
} |
q5723 | Fusebox.Request.report | train | def report (opts = {})
default_options = {
:user => 'all',
:group_subaccount => true,
:report_type => 'basic'
} | ruby | {
"resource": ""
} |
q5724 | Fusebox.Request.load_auth_from_yaml | train | def load_auth_from_yaml
self.class.auth_yaml_paths.map { |path| File.expand_path(path) }.select { |path| File.exist?(path) }.each do |path|
auth = YAML.load(File.read(path))
@username = auth['username']
@password = auth['password']
return if @username && @password
| ruby | {
"resource": ""
} |
q5725 | AppRepo.Uploader.download_manifest_only | train | def download_manifest_only
FastlaneCore::UI.message('download_manifest_only...')
rsa_key = load_rsa_key(rsa_keypath)
success = true
if !rsa_key.nil?
FastlaneCore::UI.message('Logging in with RSA key for download...')
Net::SSH.start(host, user, key_data: rsa_key, keys_only: true) ... | ruby | {
"resource": ""
} |
q5726 | AppRepo.Uploader.check_ipa | train | def check_ipa(local_ipa_path)
if File.exist?(local_ipa_path)
FastlaneCore::UI.important('IPA found at ' + local_ipa_path)
return true
| ruby | {
"resource": ""
} |
q5727 | AppRepo.Uploader.download_manifest | train | def download_manifest(sftp)
FastlaneCore::UI.message('Checking remote Manifest')
json = nil
remote_manifest_path = remote_manifest_path(appcode)
begin
sftp.stat!(remote_manifest_path) do |response|
if response.ok?
FastlaneCore::UI.success('Loading remote manifest:')... | ruby | {
"resource": ""
} |
q5728 | AppRepo.Uploader.upload_ipa | train | def upload_ipa(sftp, local_ipa_path, remote_ipa_path)
msg = "[Uploading IPA] #{local_ipa_path} to #{remote_ipa_path}"
FastlaneCore::UI.message(msg)
result = sftp.upload!(local_ipa_path, remote_ipa_path) do |event, _uploader, *_args| | ruby | {
"resource": ""
} |
q5729 | AppRepo.Uploader.upload_manifest | train | def upload_manifest(sftp, local_path, remote_path)
msg = '[Uploading Manifest] ' + local_path + ' to ' + remote_path
FastlaneCore::UI.message(msg)
result = sftp.upload!(local_path, remote_path) do |event, _uploader, *_args|
| ruby | {
"resource": ""
} |
q5730 | AppRepo.Uploader.load_rsa_key | train | def load_rsa_key(rsa_keypath)
File.open(rsa_keypath, 'r') do |file|
rsa_key = nil
rsa_key = [file.read]
if !rsa_key.nil?
| ruby | {
"resource": ""
} |
q5731 | ConstructorPages.Field.check_code_name | train | def check_code_name(code_name)
[code_name.pluralize, code_name.singularize].each {|name|
%w{self_and_ancestors descendants}.each {|m|
| ruby | {
"resource": ""
} |
q5732 | StatModule.Location.print | train | def print
result = "in #{path}"
if !begin_line.nil? && !end_line.nil?
if begin_line != end_line
if !begin_column.nil? && !end_column.nil?
result += ", line #{begin_line}:#{begin_column} to line #{end_line}:#{end_column}"
elsif !begin_column.nil? && end_column.nil?
... | ruby | {
"resource": ""
} |
q5733 | Wanikani.Level.level_items_list | train | def level_items_list(type, levels)
levels = levels.join(',') if levels.is_a?(Array)
response = api_response(type, levels)
# The vocabulary API call without specifying levels returns a | ruby | {
"resource": ""
} |
q5734 | Grabbers.GenericHttp.check_expired_resources | train | def check_expired_resources
net_resources = ::NetResource.expired
net_resources.each do |resource|
http = EM::HttpRequest.new(resource.url).get
http.callback{ |response|
resource.set_next_update
if resource_changed?(resource, response)
resource.body = respons... | ruby | {
"resource": ""
} |
q5735 | Grabbers.GenericHttp.notify_subscribers | train | def notify_subscribers(resource)
resource.subscriptions.each do |subscription|
http = EM::HttpRequest.new(subscription.url).post(:body => {:data => resource.body})
http.callback{ |response|
puts "POSTed updated data for #{resource.url}, #{resource.body.length} characters"
}
... | ruby | {
"resource": ""
} |
q5736 | Grabbers.GenericHttp.resource_changed? | train | def resource_changed?(resource, response)
changed = false
puts "checking for changes on #{resource.url}"
puts "response.response.hash: #{response.response.hash}"
| ruby | {
"resource": ""
} |
q5737 | Grabbers.GenericHttp.update_changed_resource | train | def update_changed_resource(resource, response)
resource.last_modified_hash = response.response.hash
resource.last_updated = Time.now | ruby | {
"resource": ""
} |
q5738 | FalkorLib.Config.default | train | def default
res = FalkorLib::Config::DEFAULTS.clone
$LOADED_FEATURES.each do |path|
res[:git] = FalkorLib::Config::Git::DEFAULTS if path.include?('lib/falkorlib/git.rb')
res[:gitflow] = FalkorLib::Config::GitFlow::DEFAULTS if path.include?('lib/falkorlib/git.rb')
... | ruby | {
"resource": ""
} |
q5739 | FalkorLib.Config.config_file | train | def config_file(dir = Dir.pwd, type = :local, options = {})
path = normalized_path(dir)
path = FalkorLib::Git.rootdir(path) if FalkorLib::Git.init?(path)
raise FalkorLib::Error, "Wrong | ruby | {
"resource": ""
} |
q5740 | ISE.ProjectNavigator.most_recent_project_path | train | def most_recent_project_path
#Re-load the preference file, so we have the most recent project.
@preferences = PreferenceFile.load
#And retrieve the first project in the recent projects list.
project = preference(RecentProjectsPath).split(', ').first | ruby | {
"resource": ""
} |
q5741 | CLIUtils.Configurator.ingest_prefs | train | def ingest_prefs(prefs)
fail 'Invaid Prefs class' unless prefs.kind_of?(Prefs)
prefs.prompts.each do |p|
section_sym = p.config_section.to_sym
| ruby | {
"resource": ""
} |
q5742 | CLIUtils.Configurator.method_missing | train | def method_missing(name, *args, &block)
if name[-1,1] == '='
| ruby | {
"resource": ""
} |
q5743 | Cassie::Schema.VersionLoader.load | train | def load
return false unless filename
require filename
begin
# ensure the migration class is now defined
version.migration_class_name.constantize
if version.migration.is_a?(Cassie::Schema::Migration)
version
else
| ruby | {
"resource": ""
} |
q5744 | GovDelivery::TMS::InstanceResource.ClassMethods.nullable_attributes | train | def nullable_attributes(*attrs)
@nullable_attributes ||= []
if attrs.any? | ruby | {
"resource": ""
} |
q5745 | Bullshit.ModuleFunctions.array_window | train | def array_window(array, window_size)
window_size < 1 and raise ArgumentError, "window_size = #{window_size} < 1"
window_size = window_size.to_i
window_size += 1 if window_size % 2 == 0
radius = window_size / 2
array.each_index do |i|
ws = window_size
from = i - radius
... | ruby | {
"resource": ""
} |
q5746 | Bullshit.Clock.<< | train | def <<(times)
r = times.shift
@repeat += 1 if @times[:repeat].last != | ruby | {
"resource": ""
} |
q5747 | Bullshit.Clock.analysis | train | def analysis
@analysis ||= Hash.new do |h, time|
time = time.to_sym
times = @times[time]
| ruby | {
"resource": ""
} |
q5748 | Bullshit.Clock.cover? | train | def cover?(other)
time = self.case.compare_time.to_sym
| ruby | {
"resource": ""
} |
q5749 | Bullshit.Clock.to_a | train | def to_a
if @repeat >= 1
(::Bullshit::Clock::ALL_COLUMNS).map do |t|
analysis[t].elements
| ruby | {
"resource": ""
} |
q5750 | Bullshit.Clock.take_time | train | def take_time
@time, times = Time.now, Process.times
user_time = times.utime + times.cutime # user time of this process and its children
system_time = times.stime + times.cstime # system time of this process and its children
| ruby | {
"resource": ""
} |
q5751 | Bullshit.Clock.measure | train | def measure
before = take_time
yield
after = take_time
@repeat += 1
@times[:repeat] << @repeat
@times[:scatter] << @scatter
bs = self.case.batch_size.abs
| ruby | {
"resource": ""
} |
q5752 | Bullshit.Clock.detect_autocorrelation | train | def detect_autocorrelation(time)
analysis[time.to_sym].detect_autocorrelation(
self.case.autocorrelation.max_lags.to_i, | ruby | {
"resource": ""
} |
q5753 | Bullshit.Clock.autocorrelation_plot | train | def autocorrelation_plot(time)
r = autocorrelation time
start = @times[:repeat].first
| ruby | {
"resource": ""
} |
q5754 | Bullshit.Clock.truncate_data | train | def truncate_data(offset)
for t in ALL_COLUMNS
times = @times[t]
| ruby | {
"resource": ""
} |
q5755 | Bullshit.Clock.find_truncation_offset | train | def find_truncation_offset
truncation = self.case.truncate_data
slope_angle = self.case.truncate_data.slope_angle.abs
time = self.case.compare_time.to_sym
ms = analysis[time].elements.reverse
offset = ms.size - 1
@slopes = []
ModuleFunctions.array_window(ms, truncation.window_s... | ruby | {
"resource": ""
} |
q5756 | Bullshit.CaseMethod.load | train | def load(fp = file_path)
self.clock = self.case.class.clock.new self
$DEBUG and warn "Loading '#{fp}' into clock."
File.open(fp, 'r') do |f|
f.each do |line|
line.chomp!
line | ruby | {
"resource": ""
} |
q5757 | Bullshit.Case.longest_name | train | def longest_name
bmethods.empty? and return 0
bmethods.map { | ruby | {
"resource": ""
} |
q5758 | Bullshit.Case.pre_run | train | def pre_run(bc_method)
setup_name = bc_method.setup_name
if respond_to? setup_name
| ruby | {
"resource": ""
} |
q5759 | Bullshit.Case.run_method | train | def run_method(bc_method)
pre_run bc_method
clock = self.class.clock.__send__(self.class.clock_method, bc_method) do
__send__(bc_method.name)
end | ruby | {
"resource": ""
} |
q5760 | Bullshit.Case.post_run | train | def post_run(bc_method)
teardown_name = bc_method.teardown_name
if respond_to? teardown_name
| ruby | {
"resource": ""
} |
q5761 | Bullshit.Comparison.output_filename | train | def output_filename(name)
path = File.expand_path(name, | ruby | {
"resource": ""
} |
q5762 | Inaho.Dictionary.validate | train | def validate
errors = []
schema_path = File.expand_path("../../../vendor/AppleDictionarySchema.rng", __FILE__)
schema = Nokogiri::XML::RelaxNG(File.open(schema_path))
schema.validate(Nokogiri::XML(self.to_xml)).each do |error|
errors | ruby | {
"resource": ""
} |
q5763 | Inaho.Dictionary.to_xml | train | def to_xml
xml = ""
xml << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
xml << "<d:dictionary xmlns=\"http://www.w3.org/1999/xhtml\" "
xml << "xmlns:d=\"http://www.apple.com/DTDs/DictionaryService-1.0.rng\">\n"
@entries.each do |entry|
| ruby | {
"resource": ""
} |
q5764 | Stribog.CreateHash.return_hash | train | def return_hash(final_vector)
case digest_length
when 512
create_digest(final_vector)
when 256
create_digest(vector_from_array(final_vector[0..31]))
else
raise ArgumentError, | ruby | {
"resource": ""
} |
q5765 | RepoManager.BaseAction.parse_options | train | def parse_options(parser_configuration = {})
raise_on_invalid_option = parser_configuration.has_key?(:raise_on_invalid_option) ? parser_configuration[:raise_on_invalid_option] : true
parse_base_options = parser_configuration.has_key?(:parse_base_options) ? parser_configuration[:parse_base_options] : true
... | ruby | {
"resource": ""
} |
q5766 | RepoManager.BaseAction.asset_options | train | def asset_options
# include all base action options
result = options.deep_clone
# anything left on the command line should be filters as all options have
# been consumed, for pass through options, filters must be ignored by overwritting them
filters = args.dup
filters += result[:fil... | ruby | {
"resource": ""
} |
q5767 | RepoManager.BaseAction.render | train | def render(view_options=configuration)
logger.debug "rendering"
result = ""
if template
logger.debug "rendering with template : #{template}"
view = AppView.new(items, view_options)
view.template = template
result = view.render
else
| ruby | {
"resource": ""
} |
q5768 | SiteFramework.Middleware.call | train | def call(env)
# Create a method called domain which will return the current domain
# name
Rails.application.send :define_singleton_method, 'domain_name' do
env['SERVER_NAME']
end
# Create `fetch_domain` method on `Rails.application`
# only if it didn't already define.
... | ruby | {
"resource": ""
} |
q5769 | Ripl.Fresh.loop_eval | train | def loop_eval(input)
if input == ''
@command_mode = :system and return
end
case @command_mode
when :system # generate ruby code to execute the command
if !@result_storage
ruby_command_code = "_ = system '#{ input }'\n"
else
temp_file = "/tmp/ripl-fres... | ruby | {
"resource": ""
} |
q5770 | CF.Data.to_s | train | def to_s
ptr = CF.CFDataGetBytePtr(self)
if CF::String::HAS_ENCODING
ptr.read_string(CF.CFDataGetLength(self)).force_encoding(Encoding::ASCII_8BIT)
| ruby | {
"resource": ""
} |
q5771 | RakeOE.Toolchain.set_build_vars | train | def set_build_vars
warning_flags = ' -W -Wall'
if 'release' == @config.release
optimization_flags = " #{@config.optimization_release} -DRELEASE"
else
optimization_flags = " #{@config.optimization_dbg} -g"
end
# we could make these also arrays of source directories ...
@settings['APP... | ruby | {
"resource": ""
} |
q5772 | RakeOE.Toolchain.reduce_libs_to_bare_minimum | train | def reduce_libs_to_bare_minimum(libs)
rv = libs.clone
lib_entries = RakeOE::PrjFileCache.get_lib_entries(libs)
| ruby | {
"resource": ""
} |
q5773 | RakeOE.Toolchain.libs_for_binary | train | def libs_for_binary(a_binary, visited=[])
return [] if visited.include?(a_binary)
visited << a_binary
pre = Rake::Task[a_binary].prerequisites
rv = []
pre.each do |p|
next if (File.extname(p) != '.a') && (File.extname(p) != '.so')
next if p =~ /\-app\.a/
rv << | ruby | {
"resource": ""
} |
q5774 | RakeOE.Toolchain.obj | train | def obj(params = {})
extension = File.extname(params[:source])
object = params[:object]
source = params[:source]
incs = compiler_incs_for(params[:includes]) + " #{@settings['LIB_INC']}"
case
when cpp_source_extensions.include?(extension)
flags = @settings['CXXFLAGS'] + ' ' ... | ruby | {
"resource": ""
} |
q5775 | RubyChem.Equation.solve_equivalent_fractions | train | def solve_equivalent_fractions
last = 0
array = Array.new
@reduced_row_echelon_form.each do |x|
| ruby | {
"resource": ""
} |
q5776 | RubyChem.Equation.apply_solved_equivalent_fractions_to_fraction | train | def apply_solved_equivalent_fractions_to_fraction
int = self.solve_equivalent_fractions
answer = []
@reduced_row_echelon_form.each do |row|
answer << row.last * int
end
answer << int
count = 0
@balanced = Hash.new
@left_system_of_equations.each do |x,v|
an... | ruby | {
"resource": ""
} |
q5777 | RubyChem.Equation.reduced_row_echelon_form | train | def reduced_row_echelon_form(ary)
lead = 0
rows = ary.size
cols = ary[0].size
rary = convert_to_rational(ary) # use rational arithmetic
catch :done do
rows.times do |r|
throw :done if cols <= lead
i = r
while rary[i][lead] == 0
i += 1
... | ruby | {
"resource": ""
} |
q5778 | HTTPStatus.ControllerAddition.http_status_exception | train | def http_status_exception(exception)
@exception = exception
render_options = {:template => exception.template, :status => exception.status}
render_options[:layout] = exception.template_layout | ruby | {
"resource": ""
} |
q5779 | Trace.EventBuffer.append | train | def append(event, frame, arg)
item = EventStruct.new(event, arg, frame)
@pos = self.succ_pos
@marks.shift if @marks[0] == @pos
@buf[@pos] | ruby | {
"resource": ""
} |
q5780 | ConstructorPages.Template.check_code_name | train | def check_code_name(cname)
[cname.pluralize, cname.singularize].each {|name|
return | ruby | {
"resource": ""
} |
q5781 | ExpressTemplates.Renderer.render | train | def render context=nil, template_or_src=nil, &block
compiled_template | ruby | {
"resource": ""
} |
q5782 | RepoManager.Settings.configure | train | def configure(options)
# config file default options
configuration = {
:options => {
:verbose => false,
:color => 'AUTO',
:short => false,
:unmodified => 'HIDE',
... | ruby | {
"resource": ""
} |
q5783 | Cassie::Statements::Execution.BatchedFetching.fetch_in_batches | train | def fetch_in_batches(opts={})
opts[:batch_size] ||= 1000
# spawn the new query as soon as the enumerable is created
# rather than waiting until the firt iteration is executed.
# The client could mutate the object between these moments,
# however we don't want to spawn twice if a block isn... | ruby | {
"resource": ""
} |
q5784 | GuideboxWrapper.GuideboxMovie.search_for | train | def search_for(name)
url = build_query(name)
url += '/fuzzy/web'
data = | ruby | {
"resource": ""
} |
q5785 | Snapi.Argument.valid_input? | train | def valid_input?(input)
case @attributes[:type]
when :boolean
[true,false].include?(input)
when :enum
raise MissingValuesError unless @attributes[:values]
raise InvalidValuesError unless @attributes[:values].class == Array
@attributes[:values].include?(input)
when... | ruby | {
"resource": ""
} |
q5786 | Cassie::Statements::Execution.Fetching.fetch | train | def fetch(args={})
args.each do |k, v|
setter = "#{k}="
send(setter, | ruby | {
"resource": ""
} |
q5787 | CF.Base.inspect | train | def inspect
cf = CF::String.new(CF.CFCopyDescription(self))
| ruby | {
"resource": ""
} |
q5788 | CF.Base.equals? | train | def equals?(other)
if other.is_a?(CF::Base)
| ruby | {
"resource": ""
} |
q5789 | CLIUtils.PrettyIO.color_chart | train | def color_chart
[0, 1, 4, 5, 7].each do |attr|
puts '----------------------------------------------------------------'
puts "ESC[#{attr};Foreground;Background"
30.upto(37) do |fg|
40.upto(47) do |bg|
| ruby | {
"resource": ""
} |
q5790 | Lev.Handler.validate_paramified_params | train | def validate_paramified_params
self.class.paramify_methods.each do |method|
| ruby | {
"resource": ""
} |
q5791 | GBDispatch.Queue.perform_after | train | def perform_after(time, block=nil)
task = Concurrent::ScheduledTask.new(time) do
block = ->(){ yield } unless block
| ruby | {
"resource": ""
} |
q5792 | ISE.PreferenceFile.set_by_path | train | def set_by_path(path, value, target=@ini)
#Split the path into its components.
keys = path.split('/')
#Traverse the path, creating any "folders" necessary along the | ruby | {
"resource": ""
} |
q5793 | ISE.PreferenceFile.get_by_path | train | def get_by_path(path, target=@ini)
#Split the path into its components...
keys = path.split('/')
#And traverse the hasn until we've fully navigated the path.
| ruby | {
"resource": ""
} |
q5794 | ISE.PreferenceFile.process_property | train | def process_property(property, value)
value.chomp!
#If either the property or value are empty (or contain invalid whitespace),
#abort.
return if property.empty? and value.empty?
return if value.sub!(%r/\\\s*\z/, '')
#Strip any leading/trailing characters.
property.stri... | ruby | {
"resource": ""
} |
q5795 | FalkorLib.Git.init? | train | def init?(path = Dir.pwd)
begin
MiniGit.new(path)
| ruby | {
"resource": ""
} |
q5796 | FalkorLib.Git.commits? | train | def commits?(path)
res = false
Dir.chdir(path) do
_stdout, _stderr, exit_status = Open3.capture3( "git rev-parse HEAD" )
| ruby | {
"resource": ""
} |
q5797 | FalkorLib.Git.command? | train | def command?(cmd)
cg = MiniGit::Capturing.new
cmd_list = cg.help :a => true
# typical run:
# usage: git [--version] [--help] [-C <path>] [-c name=value]
# [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
# [-p|--paginate|--no-pager] [--no-replace-... | ruby | {
"resource": ""
} |
q5798 | FalkorLib.Git.init | train | def init(path = Dir.pwd, _options = {})
# FIXME: for travis test: ensure the global git configurations
# 'user.email' and 'user.name' are set
[ 'user.name', 'user.email' ].each do |userconf|
next unless MiniGit[userconf].nil?
warn "The Git global configuration '#{userconf}' is not set ... | ruby | {
"resource": ""
} |
q5799 | FalkorLib.Git.create_branch | train | def create_branch(branch, path = Dir.pwd)
#ap method(__method__).parameters.map { |arg| arg[1] }
g = MiniGit.new(path)
error "not | ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.