_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q22600 | OneviewSDK.Cli.env | train | def env
data = {}
OneviewSDK::ENV_VARS.each { |k| data[k] = ENV[k] }
if @options['format'] == 'human'
data.each do |key, value|
value = "'#{value}'" if value && !%w[true false].include?(value)
printf "%-#{data.keys.max_by(&:length).length}s = %s\n", key, value || 'nil'
... | ruby | {
"resource": ""
} |
q22601 | OneviewSDK.Cli.show | train | def show(type, name)
resource_class = parse_type(type)
client_setup
matches = resource_class.find_by(@client, name: name)
fail_nice 'Not Found' if matches.empty?
data = matches.first.data
if options['attribute']
data = select_attributes(options['attribute'], data)
end
... | ruby | {
"resource": ""
} |
q22602 | OneviewSDK.Cli.rest | train | def rest(method, uri)
log_level = @options['log_level'] == :warn ? :error : @options['log_level'].to_sym # Default to :error
client_setup('log_level' => log_level)
uri_copy = uri.dup
uri_copy.prepend('/') unless uri_copy.start_with?('/')
if @options['data']
begin
data = {... | ruby | {
"resource": ""
} |
q22603 | OneviewSDK.Cli.update | train | def update(type, name)
resource_class = parse_type(type)
client_setup
fail_nice 'Must set the hash or json option' unless @options['hash'] || @options['json']
fail_nice 'Must set the hash OR json option. Not both' if @options['hash'] && @options['json']
begin
data = @options['hash'... | ruby | {
"resource": ""
} |
q22604 | OneviewSDK.Cli.delete | train | def delete(type, name)
resource_class = parse_type(type)
client_setup
matches = resource_class.find_by(@client, name: name)
fail_nice('Not Found', 2) if matches.empty?
resource = matches.first
return unless options['force'] || agree("Delete '#{name}'? [Y/N] ")
begin
res... | ruby | {
"resource": ""
} |
q22605 | OneviewSDK.Cli.delete_from_file | train | def delete_from_file(file_path)
client_setup
resource = OneviewSDK::Resource.from_file(@client, file_path)
fail_nice("#{resource.class.name.split('::').last} '#{resource[:name] || resource[:uri]}' Not Found", 2) unless resource.retrieve!
return unless options['force'] || agree("Delete '#{resourc... | ruby | {
"resource": ""
} |
q22606 | OneviewSDK.Cli.to_file | train | def to_file(type, name)
file = File.expand_path(options['path'])
resource_class = parse_type(type)
client_setup
resource = resource_class.find_by(@client, name: name).first
fail_nice "#{resource_class.name.split('::').last} '#{name}' not found" unless resource
resource.to_file(file, ... | ruby | {
"resource": ""
} |
q22607 | OneviewSDK.Cli.cert | train | def cert(type, url = ENV['ONEVIEWSDK_URL'])
case type.downcase
when 'check'
fail_nice 'Must specify a url' unless url
puts "Checking certificate for '#{url}' ..."
if OneviewSDK::SSLHelper.check_cert(url)
puts 'Certificate is valid!'
else
fail_nice 'Certifi... | ruby | {
"resource": ""
} |
q22608 | OneviewSDK.Cli.scmb | train | def scmb
client_setup
connection = OneviewSDK::SCMB.new_connection(@client)
q = OneviewSDK::SCMB.new_queue(connection, @options['route'])
puts 'Subscribing to OneView messages. To exit, press Ctrl + c'
q.subscribe(block: true) do |_delivery_info, _properties, payload|
data = JSON.p... | ruby | {
"resource": ""
} |
q22609 | OneviewSDK.Cli.parse_type | train | def parse_type(type)
api_ver = (@options['api_version'] || ENV['ONEVIEWSDK_API_VERSION'] || OneviewSDK.api_version).to_i
unless OneviewSDK::SUPPORTED_API_VERSIONS.include?(api_ver)
# Find and use the best available match for the desired API version (round down to nearest)
valid_api_ver = One... | ruby | {
"resource": ""
} |
q22610 | OneviewSDK.Cli.select_attributes | train | def select_attributes(attributes, data = {})
attributes = attributes.split(',').map(&:strip).reject(&:empty?).map { |a| a.split('.') } if attributes.is_a?(String)
r_data = data.is_a?(Hash) ? data : data.data
temp = {}
attributes.each do |attr|
temp_level = temp
attr = [attr] if a... | ruby | {
"resource": ""
} |
q22611 | OneviewSDK.Cli.select_attributes_from_multiple | train | def select_attributes_from_multiple(attributes, data = [])
attributes = attributes.split(',').map(&:strip).reject(&:empty?).map { |a| a.split('.') } if attributes.is_a?(String)
result = []
data.each do |r|
result.push(r['name'] => select_attributes(attributes, r))
end
result
en... | ruby | {
"resource": ""
} |
q22612 | OneviewSDK.Client.get_all | train | def get_all(type, api_ver = @api_version, variant = nil)
klass = OneviewSDK.resource_named(type, api_ver, variant)
raise TypeError, "Invalid resource type '#{type}'. OneviewSDK::API#{api_ver} does not contain a class like it." unless klass
klass.get_all(self)
end | ruby | {
"resource": ""
} |
q22613 | OneviewSDK.Client.wait_for | train | def wait_for(task_uri)
raise ArgumentError, 'Must specify a task_uri!' if task_uri.nil? || task_uri.empty?
loop do
task_uri.gsub!(%r{https:(.*)\/rest}, '/rest')
task = rest_get(task_uri)
body = JSON.parse(task.body)
case body['taskState'].downcase
when 'completed'
... | ruby | {
"resource": ""
} |
q22614 | OneviewSDK.Client.appliance_api_version | train | def appliance_api_version
options = { 'Content-Type' => :none, 'X-API-Version' => :none, 'auth' => :none }
response = rest_api(:get, '/rest/version', options)
version = response_handler(response)['currentVersion']
raise ConnectionError, "Couldn't get API version" unless version
version = v... | ruby | {
"resource": ""
} |
q22615 | OneviewSDK.Client.login | train | def login(retries = 2)
options = {
'body' => {
'userName' => @user,
'password' => @password,
'authLoginDomain' => @domain
}
}
response = rest_post('/rest/login-sessions', options)
body = response_handler(response)
return body['sessionID'] if bo... | ruby | {
"resource": ""
} |
q22616 | OneviewSDK.Rest.rest_api | train | def rest_api(type, path, options = {}, api_ver = @api_version, redirect_limit = 3)
@logger.debug "Making :#{type} rest call to #{@url}#{path}"
raise InvalidRequest, 'Must specify path' unless path
uri = URI.parse(Addressable::URI.escape(@url + path))
http = build_http_object(uri)
request =... | ruby | {
"resource": ""
} |
q22617 | OneviewSDK.Rest.upload_file | train | def upload_file(file_path, path, options = {}, timeout = READ_TIMEOUT)
raise NotFound, "ERROR: File '#{file_path}' not found!" unless File.file?(file_path)
options = Hash[options.map { |k, v| [k.to_s, v] }]
body_params = options['body'] || {}
headers_params = options['header'] || {}
header... | ruby | {
"resource": ""
} |
q22618 | OneviewSDK.Rest.download_file | train | def download_file(path, local_drive_path)
uri = URI.parse(Addressable::URI.escape(@url + path))
http_request = build_http_object(uri)
req = build_request(:get, uri, {}, @api_version.to_s)
http_request.start do |http|
http.request(req) do |res|
response_handler(res) unless res.... | ruby | {
"resource": ""
} |
q22619 | OneviewSDK.Rest.response_handler | train | def response_handler(response, wait_on_task = true)
case response.code.to_i
when RESPONSE_CODE_OK # Synchronous read/query
begin
return JSON.parse(response.body)
rescue JSON::ParserError => e
@logger.warn "Failed to parse JSON response. #{e}"
return response.bod... | ruby | {
"resource": ""
} |
q22620 | OneviewSDK.Rest.build_http_object | train | def build_http_object(uri)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true if uri.scheme == 'https'
if @ssl_enabled
http.cert_store = @cert_store if @cert_store
else http.verify_mode = OpenSSL::SSL::VERIFY_NONE
end
http.read_timeout = @timeout if @timeout # Timeo... | ruby | {
"resource": ""
} |
q22621 | OneviewSDK.Rest.build_request | train | def build_request(type, uri, options, api_ver)
case type.downcase.to_sym
when :get
request = Net::HTTP::Get.new(uri.request_uri)
when :post
request = Net::HTTP::Post.new(uri.request_uri)
when :put
request = Net::HTTP::Put.new(uri.request_uri)
when :patch
req... | ruby | {
"resource": ""
} |
q22622 | WineBouncer.OAuth2.doorkeeper_authorize! | train | def doorkeeper_authorize!(*scopes)
scopes = Doorkeeper.configuration.default_scopes if scopes.empty?
unless valid_doorkeeper_token?(*scopes)
if !doorkeeper_token || !doorkeeper_token.accessible?
error = Doorkeeper::OAuth::InvalidTokenResponse.from_access_token(doorkeeper_token)
r... | ruby | {
"resource": ""
} |
q22623 | OneviewSDK.Resource.exists? | train | def exists?(header = self.class::DEFAULT_REQUEST_HEADER)
retrieval_keys = self.class::UNIQUE_IDENTIFIERS.reject { |k| @data[k].nil? }
raise IncompleteResource, "Must set resource #{self.class::UNIQUE_IDENTIFIERS.join(' or ')} before trying to retrieve!" if retrieval_keys.empty?
retrieval_keys.each do ... | ruby | {
"resource": ""
} |
q22624 | OneviewSDK.Resource.deep_merge! | train | def deep_merge!(other_data, target_data = @data)
raise 'Both arguments should be a object Hash' unless other_data.is_a?(Hash) && target_data.is_a?(Hash)
other_data.each do |key, value|
value_target = target_data[key.to_s]
if value_target.is_a?(Hash) && value.is_a?(Hash)
deep_merge!... | ruby | {
"resource": ""
} |
q22625 | OneviewSDK.Resource.set_all | train | def set_all(params = self.class::DEFAULT_REQUEST_HEADER)
params = params.data if params.class <= Resource
params = Hash[params.map { |(k, v)| [k.to_s, v] }]
params.each { |key, value| set(key.to_s, value) }
self
end | ruby | {
"resource": ""
} |
q22626 | OneviewSDK.Resource.set | train | def set(key, value)
method_name = "validate_#{key}"
send(method_name.to_sym, value) if respond_to?(method_name.to_sym)
@data[key.to_s] = value
end | ruby | {
"resource": ""
} |
q22627 | OneviewSDK.Resource.create | train | def create(header = self.class::DEFAULT_REQUEST_HEADER)
ensure_client
options = {}.merge(header).merge('body' => @data)
response = @client.rest_post(self.class::BASE_URI, options, @api_version)
body = @client.response_handler(response)
set_all(body)
self
end | ruby | {
"resource": ""
} |
q22628 | OneviewSDK.Resource.create! | train | def create!(header = self.class::DEFAULT_REQUEST_HEADER)
temp = self.class.new(@client, @data)
temp.delete(header) if temp.retrieve!(header)
create(header)
end | ruby | {
"resource": ""
} |
q22629 | OneviewSDK.Resource.refresh | train | def refresh(header = self.class::DEFAULT_REQUEST_HEADER)
ensure_client && ensure_uri
response = @client.rest_get(@data['uri'], header, @api_version)
body = @client.response_handler(response)
set_all(body)
self
end | ruby | {
"resource": ""
} |
q22630 | OneviewSDK.Resource.update | train | def update(attributes = {}, header = self.class::DEFAULT_REQUEST_HEADER)
set_all(attributes)
ensure_client && ensure_uri
options = {}.merge(header).merge('body' => @data)
response = @client.rest_put(@data['uri'], options, @api_version)
@client.response_handler(response)
self
end | ruby | {
"resource": ""
} |
q22631 | OneviewSDK.Resource.delete | train | def delete(header = self.class::DEFAULT_REQUEST_HEADER)
ensure_client && ensure_uri
response = @client.rest_delete(@data['uri'], header, @api_version)
@client.response_handler(response)
true
end | ruby | {
"resource": ""
} |
q22632 | OneviewSDK.Resource.to_file | train | def to_file(file_path, format = :json)
format = :yml if %w[.yml .yaml].include? File.extname(file_path)
temp_data = { type: self.class.name, api_version: @api_version, data: @data }
case format.to_sym
when :json
File.open(file_path, 'w') { |f| f.write(JSON.pretty_generate(temp_data)) }
... | ruby | {
"resource": ""
} |
q22633 | OneviewSDK.Resource.recursive_like? | train | def recursive_like?(other, data = @data)
raise "Can't compare with object type: #{other.class}! Must respond_to :each" unless other.respond_to?(:each)
other.each do |key, val|
return false unless data && data.respond_to?(:[])
if val.is_a?(Hash)
return false unless data.class == Has... | ruby | {
"resource": ""
} |
q22634 | PayuIndia.Notification.amount_ok? | train | def amount_ok?( order_amount, order_discount = BigDecimal.new( '0.0' ) )
BigDecimal.new( gross ) == order_amount && BigDecimal.new( discount.to_s ) == order_discount
end | ruby | {
"resource": ""
} |
q22635 | PayuIndia.ActionViewHelper.payment_form_for_payu | train | def payment_form_for_payu(key, salt, options = {})
if !options.is_a?(Hash) || !key.is_a?(String) || !salt.is_a?(String)
concat("Something Wrong! params order -> key (String), salt (String), options (Hash) ")
nil
else
form_options = options.delete(:html) || {}
service = PayuIn... | ruby | {
"resource": ""
} |
q22636 | Sprinkle::Package.Rendering.template | train | def template(src, context=binding)
eruby = Erubis::Eruby.new(src)
eruby.result(context)
rescue Object => e
raise Sprinkle::Errors::TemplateError.new(e, src, context)
end | ruby | {
"resource": ""
} |
q22637 | Sprinkle::Package.Rendering.render | train | def render(filename, context=binding)
contents=File.read(expand_filename(filename))
template(contents, context)
end | ruby | {
"resource": ""
} |
q22638 | GamedayApi.Pitcher.load_from_id | train | def load_from_id(gid, pid)
@gid = gid
@pid = pid
@position = 'P'
@xml_data = GamedayFetcher.fetch_pitcher(gid, pid)
@xml_doc = REXML::Document.new(@xml_data)
@team_abbrev = @xml_doc.root.attributes["team"]
@first_name = @xml_doc.root.attributes["first_name"]
@last... | ruby | {
"resource": ""
} |
q22639 | GamedayApi.Pitcher.get_all_starts | train | def get_all_starts(year)
results = []
app = get_all_appearances(year)
if app.start == true
results << app
end
end | ruby | {
"resource": ""
} |
q22640 | GamedayApi.Pitcher.get_vs_ab | train | def get_vs_ab
results = []
abs = get_game.get_atbats
abs.each do |ab|
if ab.pitcher_id == @pid
results << ab
end
end
results
end | ruby | {
"resource": ""
} |
q22641 | GamedayApi.Pitcher.get_pitches | train | def get_pitches
results = []
ab = get_vs_ab
ab.each do |ab|
results << ab.pitches
end
results.flatten
end | ruby | {
"resource": ""
} |
q22642 | GamedayApi.BoxScore.load_from_id | train | def load_from_id(gid)
@gid = gid
@xml_data = GamedayFetcher.fetch_boxscore(gid)
@xml_doc = REXML::Document.new(@xml_data)
if @xml_doc.root
@game = Game.new(@gid)
@game.boxscore = self
set_basic_info
@linescore = LineScore.new
@linescore.init(@xml_... | ruby | {
"resource": ""
} |
q22643 | GamedayApi.BoxScore.to_html | train | def to_html(template_filename)
gameday_info = GamedayUtil.parse_gameday_id('gid_' + gid)
template = ERB.new File.new(File.expand_path(File.dirname(__FILE__) + "/" + template_filename)).read, nil, "%"
return template.result(binding)
end | ruby | {
"resource": ""
} |
q22644 | GamedayApi.BoxScore.set_basic_info | train | def set_basic_info
@game_id = @xml_doc.root.attributes["game_id"]
@game_pk = @xml_doc.root.attributes["game_pk"]
@home_sport_code = @xml_doc.root.attributes["home_sport_code"]
@away_team_code = @xml_doc.root.attributes["away_team_code"]
@home_team_code = @xml_doc.root.attributes["home... | ruby | {
"resource": ""
} |
q22645 | GamedayApi.BoxScore.set_pitchers | train | def set_pitchers
@pitchers, away_pitchers, home_pitchers = [], [], []
count = 1
@xml_doc.elements.each("boxscore/pitching[@team_flag='away']/pitcher") { |element|
pitcher = PitchingAppearance.new
pitcher.init(@gid, element, count)
count += 1
away_pitchers.push p... | ruby | {
"resource": ""
} |
q22646 | GamedayApi.BoxScore.set_batters | train | def set_batters
@batters, away_batters, home_batters = [], [], []
@xml_doc.elements.each("boxscore/batting[@team_flag='away']/batter") { |element|
batter = BattingAppearance.new
batter.init(element)
away_batters.push batter
}
@xml_doc.elements.each("boxscore/batti... | ruby | {
"resource": ""
} |
q22647 | GamedayApi.Team.all_games | train | def all_games(year)
if !@games
puts 'Finding all games for team...'
results = []
(START_MONTH..END_MONTH).each do |month|
puts "Month: " + month.to_s
month_s = GamedayUtil.convert_digit_to_string(month)
(1..31).each do |date|
if !GamedayUti... | ruby | {
"resource": ""
} |
q22648 | GamedayApi.Team.all_home_games | train | def all_home_games(year)
games = all_games(year)
results = games.select {|g| g.home_team_abbrev == @abrev }
end | ruby | {
"resource": ""
} |
q22649 | GamedayApi.Team.all_away_games | train | def all_away_games(year)
games = all_games(year)
results = games.select {|g| g.visit_team_abbrev == @abrev }
end | ruby | {
"resource": ""
} |
q22650 | GamedayApi.Team.games_for_date | train | def games_for_date(year, month, day)
games_page = GamedayFetcher.fetch_games_page(year, month, day)
gids = find_gid_for_date(year, month, day, games_page)
if gids
results = gids.collect {|gid| Game.new(gid) }
else
results = nil
end
results
end | ruby | {
"resource": ""
} |
q22651 | GamedayApi.Team.get_leadoff_hitters_by_year | train | def get_leadoff_hitters_by_year(year)
results = []
games = all_games(year)
games.each do |game|
boxscore = game.get_boxscore
leadoffs = boxscore.get_leadoff_hitters
if game.home_team_abbrev == @abrev
results << leadoffs[1]
else
results << le... | ruby | {
"resource": ""
} |
q22652 | GamedayApi.Team.get_leadoff_hitters_unique | train | def get_leadoff_hitters_unique(year)
hitters = get_leadoff_hitters_by_year(year)
h = {}
hitters.each {|hitter| h[hitter.batter_name]=hitter}
h.values
end | ruby | {
"resource": ""
} |
q22653 | GamedayApi.Team.get_cleanup_hitters_by_year | train | def get_cleanup_hitters_by_year(year)
results = []
games = all_games(year)
games.each do |game|
boxscore = game.get_boxscore
hitters = boxscore.get_cleanup_hitters
if game.home_team_abbrev == @abrev
results << hitters[1]
else
results << hitt... | ruby | {
"resource": ""
} |
q22654 | GamedayApi.Team.get_starters_unique | train | def get_starters_unique(year)
pitchers = get_start_pitcher_appearances_by_year(year)
h = {}
pitchers.each {|pitcher| h[pitcher.pitcher_name]=pitcher}
h.values
end | ruby | {
"resource": ""
} |
q22655 | GamedayApi.Team.get_closers_unique | train | def get_closers_unique(year)
pitchers = get_close_pitcher_appearances_by_year(year)
h = {}
pitchers.each {|pitcher| h[pitcher.pitcher_name]=pitcher}
h.values
end | ruby | {
"resource": ""
} |
q22656 | GamedayApi.Team.quality_starts_count | train | def quality_starts_count(year)
count = 0
games = all_games(year)
games.each do |game|
starters = game.get_starting_pitchers
if game.home_team_abbrev == @abrev
if starters[1].quality_start?
count = count + 1
end
else
if starter... | ruby | {
"resource": ""
} |
q22657 | GamedayApi.Team.get_opening_day_game | train | def get_opening_day_game(year)
schedule = Schedule.new(year)
oday = schedule.get_opening_day
oday_array = GamedayUtil.parse_date_string(oday)
games = games_for_date(oday_array[0], oday_array[1], oday_array[2])
if games[0] == nil
games = games_for_date(oday_array[0],
... | ruby | {
"resource": ""
} |
q22658 | GamedayApi.Team.opening_day_roster | train | def opening_day_roster(year)
game = get_opening_day_game(year)
rosters = game.get_rosters
rosters[0].team_name == city + ' ' + name ? rosters[0] : rosters[1]
end | ruby | {
"resource": ""
} |
q22659 | GamedayApi.Gameday.get_all_gids_for_date | train | def get_all_gids_for_date(year, month, day)
begin
gids = []
url = GamedayUtil.build_day_url(year, month, date)
connection = GamedayUtil.get_connection(url)
if connection
@hp = Hpricot(connection)
a = @hp.at('ul')
(a/"a").each do |link|
... | ruby | {
"resource": ""
} |
q22660 | GamedayApi.Player.load_from_id | train | def load_from_id(gid, pid)
@gid = gid
@pid = pid
# fetch players.xml file
@xml_data = GamedayFetcher.fetch_players(gid)
@xml_doc = REXML::Document.new(@xml_data)
# find specific player in the file
pelement = @xml_doc.root.elements["team/player[@id=#{pid}]"]
init(p... | ruby | {
"resource": ""
} |
q22661 | GamedayApi.Player.init_pitcher_from_scoreboard | train | def init_pitcher_from_scoreboard(element)
@first = element.attributes['first']
@last = element.attributes['last']
@wins = element.attributes['wins']
@losses = element.attributes['losses']
@era = element.attributes['era']
end | ruby | {
"resource": ""
} |
q22662 | GamedayApi.Player.at_bats_count | train | def at_bats_count
gameday_info = GamedayUtil.parse_gameday_id(@gid)
appearances = get_all_appearances(gameday_info["year"])
count = appearances.inject(0) {|sum, a| sum + a.ab.to_i }
end | ruby | {
"resource": ""
} |
q22663 | GamedayApi.Player.init | train | def init(element, gid)
@gid = gid
@pid = element.attributes['id']
@first = element.attributes['first']
@last = element.attributes['last']
@num= element.attributes['num']
@boxname = element.attributes['boxname']
@rl, = element.attributes['rl']
@position = element.a... | ruby | {
"resource": ""
} |
q22664 | GamedayApi.DataDownloader.download_all_for_game | train | def download_all_for_game(gid)
download_xml_for_game(gid)
download_batters_for_game(gid)
download_inning_for_game(gid)
download_media_for_game(gid)
download_notification_for_game(gid)
download_onbase_for_game(gid)
download_pitchers_for_game(gid)
end | ruby | {
"resource": ""
} |
q22665 | GamedayApi.DataDownloader.write_file | train | def write_file(file_path, gd_data)
if gd_data && !File.exists?(file_path)
FileUtils.mkdir_p(File.dirname(file_path))
File.open(file_path, "wb") do |data|
data << gd_data
end
end
end | ruby | {
"resource": ""
} |
q22666 | GamedayApi.Game.load_from_scoreboard | train | def load_from_scoreboard(element)
@away_innings = []
@home_innings = []
@scoreboard_game_id = element.attributes['id']
@ampm = element.attributes['ampm']
@venue = element.attributes['venue']
@game_pk = element.attributes['game_pk']
@time = element.attribute... | ruby | {
"resource": ""
} |
q22667 | GamedayApi.Game.set_status | train | def set_status(element)
element.elements.each("status") { |status|
@status = GameStatus.new
@status.status = status.attributes['status']
@status.ind = status.attributes['ind']
@status.reason = status.attributes['reason']
@status.inning = status.attributes[... | ruby | {
"resource": ""
} |
q22668 | GamedayApi.Game.set_innings | train | def set_innings(element)
element.elements.each("linescore/inning") { |element|
@away_innings << element.attributes['away']
@home_innings << element.attributes['home']
}
end | ruby | {
"resource": ""
} |
q22669 | GamedayApi.Game.set_homeruns | train | def set_homeruns(element)
@homeruns = []
element.elements.each("home_runs/player") do |hr|
player = Player.new
player.last = hr.attributes['last']
player.first = hr.attributes['first']
player.hr = hr.attributes['hr']
player.std_hr = hr.attributes[... | ruby | {
"resource": ""
} |
q22670 | GamedayApi.Game.get_pitchers | train | def get_pitchers(home_or_away)
if self.gid
bs = get_boxscore
if home_or_away == 'away'
bs.pitchers[0]
else
bs.pitchers[1]
end
else
puts "No data for input specified"
end
end | ruby | {
"resource": ""
} |
q22671 | GamedayApi.Game.get_pitches | train | def get_pitches(pid)
results = []
atbats = get_atbats
atbats.each do |ab|
if ab.pitcher_id == pid
results << ab.pitches
end
end
results.flatten
end | ruby | {
"resource": ""
} |
q22672 | GamedayApi.Game.get_batters | train | def get_batters(home_or_away)
if self.gid
bs = get_boxscore
if home_or_away == 'away'
bs.batters[0]
else
bs.batters[1]
end
else
puts "No data for input specified"
end
end | ruby | {
"resource": ""
} |
q22673 | GamedayApi.Game.get_winner | train | def get_winner
ls = get_boxscore.linescore
if ls.home_team_runs > ls.away_team_runs
return home_team_abbrev
else
return visit_team_abbrev
end
end | ruby | {
"resource": ""
} |
q22674 | GamedayApi.Game.get_innings | train | def get_innings
if @innings.length == 0
inn_count = get_num_innings
(1..get_num_innings).each do |inn|
inning = Inning.new
inning.load_from_id(@gid, inn)
@innings << inning
end
end
@innings
end | ruby | {
"resource": ""
} |
q22675 | GamedayApi.Game.get_atbats | train | def get_atbats
atbats = []
innings = get_innings
innings.each do |inning|
inning.top_atbats.each do |atbat|
atbats << atbat
end
inning.bottom_atbats.each do |atbat|
atbats << atbat
end
end
atbats
end | ruby | {
"resource": ""
} |
q22676 | GamedayApi.LineScore.init | train | def init(element)
@xml_doc = element
self.away_team_runs = element.attributes["away_team_runs"]
self.away_team_hits = element.attributes["away_team_hits"]
self.away_team_errors = element.attributes["away_team_errors"]
self.home_team_runs = element.attributes["home_team_runs"]
... | ruby | {
"resource": ""
} |
q22677 | GamedayApi.BattingAppearance.get_player | train | def get_player
if !self.player
# retrieve player object
player = Player.new
player.init()
self.player = player
end
self.player
end | ruby | {
"resource": ""
} |
q22678 | GamedayApi.Inning.load_from_id | train | def load_from_id(gid, inning)
@top_atbats = []
@bottom_atbats = []
@gid = gid
begin
@xml_data = GamedayFetcher.fetch_inningx(gid, inning)
@xml_doc = REXML::Document.new(@xml_data)
if @xml_doc.root
@num = @xml_doc.root.attributes["num"]
@away_t... | ruby | {
"resource": ""
} |
q22679 | GamedayApi.Roster.init | train | def init(element, gid)
self.gid = gid
self.team_name = element.attributes['name']
self.id = element.attributes['id']
self.type = element.attributes['type']
self.players = []
self.coaches = []
self.set_players(element)
self.set_coaches(element)
end | ruby | {
"resource": ""
} |
q22680 | GrapeDeviseTokenAuth.DeviseInterface.set_user_in_warden | train | def set_user_in_warden(scope, resource)
scope = Devise::Mapping.find_scope!(scope)
warden.set_user(resource, scope: scope, store: false)
end | ruby | {
"resource": ""
} |
q22681 | GamedayApi.DbImporter.import_team_for_month | train | def import_team_for_month(team_abbrev, year, month)
start_date = Date.new(year.to_i, month.to_i) # first day of month
end_date = (start_date >> 1)-1 # last day of month
((start_date)..(end_date)).each do |dt|
puts year.to_s + '/' + month.to_s + '/' + dt.day
team = Team.new('det')... | ruby | {
"resource": ""
} |
q22682 | Beaker.Docker.install_ssh_components | train | def install_ssh_components(container, host)
case host['platform']
when /ubuntu/, /debian/
container.exec(%w(apt-get update))
container.exec(%w(apt-get install -y openssh-server openssh-client))
when /cumulus/
container.exec(%w(apt-get update))
container.exec(%w(apt-get ... | ruby | {
"resource": ""
} |
q22683 | Beaker.Docker.fix_ssh | train | def fix_ssh(container, host=nil)
@logger.debug("Fixing ssh on container #{container.id}")
container.exec(['sed','-ri',
's/^#?PermitRootLogin .*/PermitRootLogin yes/',
'/etc/ssh/sshd_config'])
container.exec(['sed','-ri',
's/^#?PasswordA... | ruby | {
"resource": ""
} |
q22684 | Beaker.Docker.find_container | train | def find_container(host)
id = host['docker_container_id']
name = host['docker_container_name']
return unless id || name
containers = ::Docker::Container.all
if id
@logger.debug("Looking for an existing container with ID #{id}")
container = containers.select { |c| c.id == ... | ruby | {
"resource": ""
} |
q22685 | GamedayApi.Players.load_from_id | train | def load_from_id(gid)
@gid = gid
@rosters = []
@umpires = {}
@xml_data = GamedayFetcher.fetch_players(gid)
@xml_doc = REXML::Document.new(@xml_data)
if @xml_doc.root
self.set_rosters
self.set_umpires
end
end | ruby | {
"resource": ""
} |
q22686 | GamedayApi.PitchfxDbManager.update_rosters | train | def update_rosters(game, away_id, home_id)
game_id = find_or_create_game(game, nil, nil)
gameday_info = GamedayUtil.parse_gameday_id('gid_' + game.gid)
active_date = "#{gameday_info['year']}/#{gameday_info['month']}/#{gameday_info['day']}"
away_res = @db.query("select... | ruby | {
"resource": ""
} |
q22687 | GamedayApi.PitchfxDbManager.update_umpire_ids_for_games | train | def update_umpire_ids_for_games
ump_id_hp = nil
ump_id_1b = nil
ump_id_2b = nil
ump_id_3b = nil
res = @db.query("select id, umpire_hp_id, umpire_1b_id, umpire_2b_id, umpire_3b_id from games")
res.each do |row| # each game
game_id = row[0]
umpir... | ruby | {
"resource": ""
} |
q22688 | GamedayApi.EventLog.load_from_id | train | def load_from_id(gid)
@gid = gid
@xml_data = GamedayFetcher.fetch_eventlog(gid)
@xml_doc = REXML::Document.new(@xml_data)
if @xml_doc.root
set_teams
set_events
end
end | ruby | {
"resource": ""
} |
q22689 | GamedayApi.EventLog.set_teams | train | def set_teams
@xml_doc.elements.each("game/team[@home_team='false']") do |element|
@away_team = element.attributes["name"]
end
@xml_doc.elements.each("game/team[@home_team='true']") do |element|
@home_team = element.attributes["name"]
end
end | ruby | {
"resource": ""
} |
q22690 | Jimson.Server.call | train | def call(env)
req = Rack::Request.new(env)
resp = Rack::Response.new
return resp.finish if !req.post?
resp.write process(req.body.read)
resp.finish
end | ruby | {
"resource": ""
} |
q22691 | Logdna.Client.buffer | train | def buffer(msg, opts)
buffer_size = write_to_buffer(msg, opts)
unless buffer_size.nil?
process_buffer(buffer_size)
end
end | ruby | {
"resource": ""
} |
q22692 | Logdna.Client.flush | train | def flush()
if defined? @@request and !@@request.nil?
request_messages = []
@lock.synchronize do
request_messages = @messages
@buffer.truncate(0)
@messages = []
end
return if request_messages.empty?
real = {
e: 'ls',
ls: re... | ruby | {
"resource": ""
} |
q22693 | Riddle.Client.run | train | def run
response = Response.new request(:search, @queue)
results = @queue.collect do
result = {
:matches => [],
:fields => [],
:attributes => {},
:attribute_names => [],
:words => {}
}
result[:status]... | ruby | {
"resource": ""
} |
q22694 | Riddle.Client.query | train | def query(search, index = '*', comments = '')
@queue.clear
@queue << query_message(search, index, comments)
self.run.first
end | ruby | {
"resource": ""
} |
q22695 | Riddle.Client.update | train | def update(index, attributes, values_by_doc)
response = Response.new request(
:update,
update_message(index, attributes, values_by_doc)
)
response.next_int
end | ruby | {
"resource": ""
} |
q22696 | Riddle.Client.query_message | train | def query_message(search, index, comments = '')
message = Message.new
# Mode, Limits
message.append_ints @offset, @limit, MatchModes[@match_mode]
# Ranking
message.append_int RankModes[@rank_mode]
message.append_string @rank_expr if @rank_mode == :expr
# Sort Mode
mess... | ruby | {
"resource": ""
} |
q22697 | Riddle.Client.excerpts_message | train | def excerpts_message(options)
message = Message.new
message.append [0, excerpt_flags(options)].pack('N2') # 0 = mode
message.append_string options[:index]
message.append_string options[:words]
# options
message.append_string options[:before_match]
message.append_string option... | ruby | {
"resource": ""
} |
q22698 | Riddle.Client.update_message | train | def update_message(index, attributes, values_by_doc)
message = Message.new
message.append_string index
message.append_array attributes
message.append_int values_by_doc.length
values_by_doc.each do |key,values|
message.append_64bit_int key # document ID
message.append_ints... | ruby | {
"resource": ""
} |
q22699 | Riddle.Client.keywords_message | train | def keywords_message(query, index, return_hits)
message = Message.new
message.append_string query
message.append_string index
message.append_int return_hits ? 1 : 0
message.to_s
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.