_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q12100 | Generamba.CatalogDownloader.update_all_catalogs_and_return_filepaths | train | def update_all_catalogs_and_return_filepaths
does_rambafile_exist = Dir[RAMBAFILE_NAME].count > 0
if does_rambafile_exist
rambafile = YAML.load_file(RAMBAFILE_NAME)
catalogs = rambafile[CATALOGS_KEY]
end
terminator = CatalogTerminator.new
terminator.remove_all_catalogs
... | ruby | {
"resource": ""
} |
q12101 | Generamba.CatalogDownloader.download_catalog | train | def download_catalog(name, url)
catalogs_local_path = Pathname.new(ENV['HOME'])
.join(GENERAMBA_HOME_DIR)
.join(CATALOGS_DIR)
current_catalog_path = catalogs_local_path
.join(name) | ruby | {
"resource": ""
} |
q12102 | Generamba.TemplateInstallerFactory.installer_for_type | train | def installer_for_type(type)
case type
when TemplateDeclarationType::LOCAL_TEMPLATE
return Generamba::LocalInstaller.new
when TemplateDeclarationType::REMOTE_TEMPLATE
return Generamba::RemoteInstaller.new
| ruby | {
"resource": ""
} |
q12103 | Generamba.CatalogInstaller.browse_catalog_for_a_template | train | def browse_catalog_for_a_template(catalog_path, template_name)
template_path = catalog_path.join(template_name) | ruby | {
"resource": ""
} |
q12104 | Generamba.TemplateProcessor.install_templates | train | def install_templates(rambafile)
# We always clear previously installed templates to avoid conflicts in different versions
clear_installed_templates
templates = rambafile[TEMPLATES_KEY]
if !templates || templates.count == 0
puts 'You must specify at least one template in Rambafile unde... | ruby | {
"resource": ""
} |
q12105 | Generamba.TemplateProcessor.clear_installed_templates | train | def clear_installed_templates
install_path = Pathname.new(TEMPLATES_FOLDER)
| ruby | {
"resource": ""
} |
q12106 | Generamba.TemplateProcessor.update_catalogs_if_needed | train | def update_catalogs_if_needed(catalogs, templates)
needs_update = templates.any? {|template| template.type == TemplateDeclarationType::CATALOG_TEMPLATE}
return unless needs_update
terminator = CatalogTerminator.new
terminator.remove_all_catalogs
puts('Updating shared generamba-catalog sp... | ruby | {
"resource": ""
} |
q12107 | Xcodeproj.XCScheme.configure_with_targets | train | def configure_with_targets(runnable_target, test_target, launch_target: false)
if runnable_target
add_build_target(runnable_target)
| ruby | {
"resource": ""
} |
q12108 | Xcodeproj.XCScheme.set_launch_target | train | def set_launch_target(build_target)
launch_runnable = BuildableProductRunnable.new(build_target, 0)
launch_action.buildable_product_runnable = launch_runnable
profile_runnable = BuildableProductRunnable.new(build_target)
profile_action.buildable_product_runnable = | ruby | {
"resource": ""
} |
q12109 | Xcodeproj.XCScheme.save_as | train | def save_as(project_path, name, shared = true)
scheme_folder_path = if shared
self.class.shared_data_dir(project_path)
else
| ruby | {
"resource": ""
} |
q12110 | Xcodeproj.Project.initialize_from_file | train | def initialize_from_file
pbxproj_path = path + 'project.pbxproj'
plist = Plist.read_from_path(pbxproj_path.to_s)
root_object.remove_referrer(self) if root_object
@root_object = new_from_plist(plist['rootObject'], plist['objects'], self)
@archive_version = plist['archiveVersion']
... | ruby | {
"resource": ""
} |
q12111 | Xcodeproj.Project.to_tree_hash | train | def to_tree_hash
hash = {}
objects_dictionary = {}
hash['objects'] = objects_dictionary
hash['archiveVersion'] = archive_version.to_s
hash['objectVersion'] = object_version.to_s
| ruby | {
"resource": ""
} |
q12112 | Xcodeproj.Project.generate_available_uuid_list | train | def generate_available_uuid_list(count = 100)
new_uuids = (0..count).map { SecureRandom.hex(12).upcase } | ruby | {
"resource": ""
} |
q12113 | Xcodeproj.Project.reference_for_path | train | def reference_for_path(absolute_path)
absolute_pathname = Pathname.new(absolute_path)
unless absolute_pathname.absolute?
raise ArgumentError, "Paths must be absolute #{absolute_path}"
end | ruby | {
"resource": ""
} |
q12114 | Xcodeproj.Project.embedded_targets_in_native_target | train | def embedded_targets_in_native_target(native_target)
native_targets.select do |target|
| ruby | {
"resource": ""
} |
q12115 | Xcodeproj.Project.host_targets_for_embedded_target | train | def host_targets_for_embedded_target(embedded_target)
native_targets.select do |native_target|
((embedded_target.uuid != native_target.uuid) &&
| ruby | {
"resource": ""
} |
q12116 | Xcodeproj.Project.new_resources_bundle | train | def new_resources_bundle(name, platform, product_group = nil)
product_group | ruby | {
"resource": ""
} |
q12117 | Xcodeproj.Project.add_build_configuration | train | def add_build_configuration(name, type)
build_configuration_list = root_object.build_configuration_list
if build_configuration = build_configuration_list[name]
build_configuration
else
build_configuration = new(XCBuildConfiguration)
build_configuration.name = | ruby | {
"resource": ""
} |
q12118 | Xcodeproj.Config.save_as | train | def save_as(pathname, prefix = nil)
if File.exist?(pathname)
return if Config.new(pathname) == self
end
| ruby | {
"resource": ""
} |
q12119 | Xcodeproj.Config.hash_from_file_content | train | def hash_from_file_content(string)
hash = {}
string.split("\n").each do |line|
uncommented_line = strip_comment(line)
if include = extract_include(uncommented_line)
@includes.push normalized_xcconfig_path(include)
else
key, value = extract_key_value(uncommented_li... | ruby | {
"resource": ""
} |
q12120 | Xcodeproj.Config.merge_attributes! | train | def merge_attributes!(attributes)
@attributes.merge!(attributes) do |_, v1, v2|
v1 = v1.strip
v2 = v2.strip
v1_split = v1.shellsplit
v2_split = v2.shellsplit
if (v2_split - v1_split).empty? || v1_split.first(v2_split.size) == v2_split
v1
| ruby | {
"resource": ""
} |
q12121 | Xcodeproj.Config.extract_key_value | train | def extract_key_value(line)
match = line.match(KEY_VALUE_PATTERN)
if match
key = match[1]
| ruby | {
"resource": ""
} |
q12122 | SpecHelper.ProjectHelper.compare_settings | train | def compare_settings(produced, expected, params)
it 'should match build settings' do
# Find faulty settings in different categories
missing_settings = expected.keys.reject { |k| produced.key?(k) }
unexpected_settings = produced.keys.reject { |k| expected.key?(k) }
wrong_settings... | ruby | {
"resource": ""
} |
q12123 | SpecHelper.ProjectHelper.load_settings | train | def load_settings(path, type)
# Load fixture
base_path = Pathname(fixture_path("CommonBuildSettings/configs/#{path}"))
config_fixture = base_path + "#{path}_#{type}.xcconfig"
config = Xcodeproj::Config.new(config_fixture)
settings = config.to_hash
# Filter exclusions
settings ... | ruby | {
"resource": ""
} |
q12124 | Xcodeproj.Workspace.save_as | train | def save_as(path)
FileUtils.mkdir_p(path)
File.open(File.join(path, | ruby | {
"resource": ""
} |
q12125 | Xcodeproj.Workspace.load_schemes_from_project | train | def load_schemes_from_project(project_full_path)
schemes = Xcodeproj::Project.schemes project_full_path
schemes.each do | ruby | {
"resource": ""
} |
q12126 | EPUBMaker.EPUBCommon.container | train | def container
@opf_path = opf_path
tmplfile = File.expand_path('./xml/container.xml.erb', ReVIEW::Template::TEMPLATE_DIR)
tmpl = | ruby | {
"resource": ""
} |
q12127 | EPUBMaker.EPUBCommon.mytoc | train | def mytoc
@title = CGI.escapeHTML(@producer.res.v('toctitle'))
@body = %Q( <h1 class="toc-title">#{CGI.escapeHTML(@producer.res.v('toctitle'))}</h1>\n)
if @producer.config['epubmaker']['flattoc'].nil?
@body << hierarchy_ncx('ul')
else
@body << flat_ncx('ul', @producer.config['e... | ruby | {
"resource": ""
} |
q12128 | ReVIEW.Compiler.compile_inline | train | def compile_inline(str)
op, arg = /\A@<(\w+)>\{(.*?)\}\z/.match(str).captures
unless inline_defined?(op)
raise CompileError, "no such inline op: #{op}"
end
unless @strategy.respond_to?("inline_#{op}")
raise "strategy does not support inline op: @<#{op}>"
| ruby | {
"resource": ""
} |
q12129 | EPUBMaker.Producer.load | train | def load(file)
if file.nil? || !File.exist?(file)
raise "Can't open #{file}."
end
loader = ReVIEW::YAMLLoader.new
| ruby | {
"resource": ""
} |
q12130 | EPUBMaker.Producer.merge_config | train | def merge_config(config)
@config.deep_merge!(config)
complement
unless @config['epubversion'].nil?
case @config['epubversion'].to_i
when 2
@epub = EPUBMaker::EPUBv2.new(self)
when 3
@epub = EPUBMaker::EPUBv3.new(self)
else
| ruby | {
"resource": ""
} |
q12131 | EPUBMaker.Producer.mimetype | train | def mimetype(wobj)
s = @epub.mimetype
if !s.nil? && !wobj.nil?
| ruby | {
"resource": ""
} |
q12132 | EPUBMaker.Producer.opf | train | def opf(wobj)
s = @epub.opf
if !s.nil? && !wobj.nil?
| ruby | {
"resource": ""
} |
q12133 | EPUBMaker.Producer.ncx | train | def ncx(wobj, indentarray = [])
s = @epub.ncx(indentarray)
if !s.nil? && | ruby | {
"resource": ""
} |
q12134 | EPUBMaker.Producer.container | train | def container(wobj)
s = @epub.container
if !s.nil? && | ruby | {
"resource": ""
} |
q12135 | EPUBMaker.Producer.colophon | train | def colophon(wobj)
s = @epub.colophon
if !s.nil? && !wobj.nil? | ruby | {
"resource": ""
} |
q12136 | EPUBMaker.Producer.mytoc | train | def mytoc(wobj)
s = @epub.mytoc
if !s.nil? && !wobj.nil?
| ruby | {
"resource": ""
} |
q12137 | EPUBMaker.EPUBv2.ncx | train | def ncx(indentarray)
@ncx_isbn = ncx_isbn
@ncx_doctitle = ncx_doctitle
@ncx_navmap = ncx_navmap(indentarray)
tmplfile = | ruby | {
"resource": ""
} |
q12138 | EPUBMaker.EPUBv2.produce | train | def produce(epubfile, basedir, tmpdir)
produce_write_common(basedir, tmpdir)
File.open("#{tmpdir}/OEBPS/#{@producer.config['bookname']}.ncx", 'w') do |f|
@producer.ncx(f, @producer.config['epubmaker']['ncxindent'])
end
if @producer.config['mytoc']
File.open("#{tmpdir}/OEBPS/#{@p... | ruby | {
"resource": ""
} |
q12139 | ReVIEW.LATEXBuilder.inline_i | train | def inline_i(str)
if @book.config.check_version('2', exception: false)
macro('textit', escape(str))
else
| ruby | {
"resource": ""
} |
q12140 | ReVIEW.YAMLLoader.load_file | train | def load_file(yamlfile)
file_queue = [File.expand_path(yamlfile)]
loaded_files = {}
yaml = {}
loop do
# Check exit condition
return yaml if file_queue.empty?
current_file = file_queue.shift
current_yaml = YAML.load_file(current_file)
yaml = current_yaml.... | ruby | {
"resource": ""
} |
q12141 | EPUBMaker.Content.complement | train | def complement
if @id.nil?
@id = @file.gsub(%r{[\\/\. ]}, '-')
end
if @id =~ /\A[^a-z]/i
@id = "rv-#{@id}"
end
if !@file.nil? && @media.nil?
@media = @file.sub(/.+\./, '').downcase
end
case @media
when 'xhtml', 'xml', 'html'
@media = 'app... | ruby | {
"resource": ""
} |
q12142 | Split.Trial.choose! | train | def choose!(context = nil)
@user.cleanup_old_experiments!
# Only run the process once
return alternative if @alternative_choosen
if override_is_alternative?
self.alternative = @options[:override]
if should_store_alternative? && !@user[@experiment.key]
self.alternative.... | ruby | {
"resource": ""
} |
q12143 | Mysql2.Client.parse_connect_attrs | train | def parse_connect_attrs(conn_attrs)
return {} if Mysql2::Client::CONNECT_ATTRS.zero?
conn_attrs ||= {}
| ruby | {
"resource": ""
} |
q12144 | Mysql2.Error.clean_message | train | def clean_message(message)
if @server_version && @server_version > 50500
message.encode(ENCODE_OPTS)
else
| ruby | {
"resource": ""
} |
q12145 | RspecApiDocumentation.DSL.resource | train | def resource(*args, &block)
options = args.last.is_a?(Hash) ? args.pop : {}
options[:api_doc_dsl] = :resource
options[:resource_name] = args.first.to_s
options[:document] = :all | ruby | {
"resource": ""
} |
q12146 | RspecApiDocumentation.Configuration.define_group | train | def define_group(name, &block)
subconfig = self.class.new(self)
subconfig.filter = name
subconfig.docs_dir | ruby | {
"resource": ""
} |
q12147 | ActiveRecordQueryTrace.CustomLogSubscriber.lines_to_display | train | def lines_to_display(full_trace)
ActiveRecordQueryTrace.lines.zero? | ruby | {
"resource": ""
} |
q12148 | ActiveRecordQueryTrace.CustomLogSubscriber.setup_backtrace_cleaner_path | train | def setup_backtrace_cleaner_path
return unless Rails.backtrace_cleaner.instance_variable_get(:@root) | ruby | {
"resource": ""
} |
q12149 | Stripe.StripeObject.update_attributes | train | def update_attributes(values, opts = {}, dirty: true)
values.each do |k, v|
add_accessors([k], values) unless metaclass.method_defined?(k.to_sym)
@values[k] | ruby | {
"resource": ""
} |
q12150 | Stripe.StripeObject.empty_values | train | def empty_values(obj)
values = case obj
when Hash then obj
when StripeObject then obj.instance_variable_get(:@values)
else
raise ArgumentError, "#empty_values | ruby | {
"resource": ""
} |
q12151 | Stripe.ListObject.auto_paging_each | train | def auto_paging_each(&blk)
return enum_for(:auto_paging_each) unless block_given?
| ruby | {
"resource": ""
} |
q12152 | Stripe.StripeClient.format_app_info | train | def format_app_info(info)
str = info[:name]
str = "#{str}/#{info[:version]}" unless info[:version].nil?
str | ruby | {
"resource": ""
} |
q12153 | Stripe.StripeClient.specific_oauth_error | train | def specific_oauth_error(resp, error_code, context)
description = resp.data[:error_description] || error_code
Util.log_error("Stripe OAuth error",
status: resp.http_status,
error_code: error_code,
error_description: description,
... | ruby | {
"resource": ""
} |
q12154 | AwesomePrint.ActiveRecord.awesome_active_record_instance | train | def awesome_active_record_instance(object)
return object.inspect if !defined?(::ActiveSupport::OrderedHash)
return awesome_object(object) if @options[:raw]
data = if object.class.column_names != object.attributes.keys
object.attributes
else
object.class.colu... | ruby | {
"resource": ""
} |
q12155 | AwesomePrint.Ripple.awesome_ripple_document_instance | train | def awesome_ripple_document_instance(object)
return object.inspect if !defined?(::ActiveSupport::OrderedHash)
return awesome_object(object) if @options[:raw]
exclude_assoc = @options[:exclude_assoc] or @options[:exclude_associations]
data = object.attributes.inject(::ActiveSupport::OrderedHash.... | ruby | {
"resource": ""
} |
q12156 | AwesomePrint.MongoMapper.awesome_mongo_mapper_instance | train | def awesome_mongo_mapper_instance(object)
return object.inspect if !defined?(::ActiveSupport::OrderedHash)
return awesome_object(object) if @options[:raw]
data = object.keys.keys.sort_by { |k| k }.inject(::ActiveSupport::OrderedHash.new) do |hash, name|
hash[name] = object[name]
hash
... | ruby | {
"resource": ""
} |
q12157 | AwesomePrint.ActionView.ap_debug | train | def ap_debug(object, options = {})
object.ai(
options.merge(html: true) | ruby | {
"resource": ""
} |
q12158 | ComfortableMexicanSofa::ActsAsTree.InstanceMethods.ancestors | train | def ancestors
node = self
nodes = []
nodes << node | ruby | {
"resource": ""
} |
q12159 | ComfortableMexicanSofa::ActsAsTree.InstanceMethods.descendants | train | def descendants
nodes = []
children.each do |c|
nodes << c
| ruby | {
"resource": ""
} |
q12160 | ComfortableMexicanSofa::Seeds.Exporter.export! | train | def export!(classes = nil)
classes ||= SEED_CLASSES
classes.each do |klass|
klass = | ruby | {
"resource": ""
} |
q12161 | ComfortableMexicanSofa::Seeds.Exporter.write_file_content | train | def write_file_content(path, data)
::File.open(::File.join(path), "wb") do |f|
data.each do |item|
f.write("[#{item[:header]}]\n")
| ruby | {
"resource": ""
} |
q12162 | ComfortableMexicanSofa::Seeds::Page.Exporter.fragments_data | train | def fragments_data(record, page_path)
record.fragments.collect do |frag|
header = "#{frag.tag} #{frag.identifier}"
content =
case frag.tag
when "datetime", "date"
frag.datetime
when "checkbox"
frag.boolean
| ruby | {
"resource": ""
} |
q12163 | ComfortableMexicanSofa::Seeds::Page.Importer.import_translations | train | def import_translations(path, page)
old_translations = page.translations.pluck(:locale)
new_translations = []
Dir["#{path}content.*.html"].each do |file_path|
locale = File.basename(file_path).match(%r{content\.(\w+)\.html})[1]
new_translations << locale
translation = page.tr... | ruby | {
"resource": ""
} |
q12164 | ComfortableMexicanSofa::Seeds::Page.Importer.construct_fragments_attributes | train | def construct_fragments_attributes(hash, record, path)
frag_identifiers = []
frag_attributes = hash.collect do |frag_header, frag_content|
tag, identifier = frag_header.split
frag_hash = {
identifier: identifier,
tag: tag
}
# tracking fragments tha... | ruby | {
"resource": ""
} |
q12165 | ComfortableMexicanSofa::Seeds::Page.Importer.files_content | train | def files_content(record, identifier, path, frag_content)
# preparing attachments
files = frag_content.split("\n").collect do |filename|
file_handler = File.open(File.join(path, filename))
{
io: file_handler,
| ruby | {
"resource": ""
} |
q12166 | Comfy.CmsHelper.cms_fragment_render | train | def cms_fragment_render(identifier, page = @cms_page)
node = page.fragment_nodes.detect { |n| n.identifier == identifier.to_s }
return "" unless node
| ruby | {
"resource": ""
} |
q12167 | Comfy.CmsHelper.cms_snippet_render | train | def cms_snippet_render(identifier, cms_site = @cms_site)
cms_site ||= cms_site_detect
snippet = cms_site&.snippets&.find_by_identifier(identifier)
return "" unless snippet
r = | ruby | {
"resource": ""
} |
q12168 | Comfy.CmsHelper.comfy_paginate | train | def comfy_paginate(collection)
return unless collection
if defined?(WillPaginate)
| ruby | {
"resource": ""
} |
q12169 | JIRA.Client.post | train | def post(path, body = '', headers = {})
headers = { 'Content-Type' => | ruby | {
"resource": ""
} |
q12170 | JIRA.Base.respond_to? | train | def respond_to?(method_name, _include_all = false)
if attrs.key?(method_name.to_s)
| ruby | {
"resource": ""
} |
q12171 | JIRA.Base.method_missing | train | def method_missing(method_name, *_args)
if attrs.key?(method_name.to_s)
| ruby | {
"resource": ""
} |
q12172 | JIRA.Base.fetch | train | def fetch(reload = false, query_params = {})
return if expanded? && !reload
response | ruby | {
"resource": ""
} |
q12173 | JIRA.Base.set_attrs_from_response | train | def set_attrs_from_response(response)
unless response.body.nil? || (response.body.length < 2)
| ruby | {
"resource": ""
} |
q12174 | JIRA.Base.set_attrs | train | def set_attrs(hash, clobber = true, target = nil)
target ||= @attrs
if clobber
target.merge!(hash)
hash
else
hash.each do |k, v|
if v.is_a?(Hash)
| ruby | {
"resource": ""
} |
q12175 | Que.JobMethods._run | train | def _run(args: nil, reraise_errors: false)
if args.nil? && que_target
args = que_target.que_attrs.fetch(:args)
end
run(*args)
default_resolve_action if que_target && !que_target.que_resolved
rescue => error
raise error unless que_target
| ruby | {
"resource": ""
} |
q12176 | Que.JobMethods.handle_error | train | def handle_error(error)
return unless que_target
max = resolve_que_setting(:maximum_retry_count)
if max && error_count > max
| ruby | {
"resource": ""
} |
q12177 | Que.JobMethods.retry_in | train | def retry_in(period)
return unless que_target
if id = que_target.que_attrs[:id]
values = [period]
if e = que_target.que_error
values << "#{e.class}: #{e.message}".slice(0, 500) << e.backtrace.join("\n").slice(0, 10000)
else
| ruby | {
"resource": ""
} |
q12178 | Que.JobBuffer.push | train | def push(*metajobs)
Que.internal_log(:job_buffer_push, self) do
{
maximum_size: maximum_size,
ids: metajobs.map(&:id),
current_queue: to_a,
}
end
sync do
return metajobs if _stopping?
@array.concat(metajobs).sort!
# Re... | ruby | {
"resource": ""
} |
q12179 | Middleman.DnsResolver.ips_for | train | def ips_for(name)
resolvers.each do |r|
ips = r.getaddresses(name)
| ruby | {
"resource": ""
} |
q12180 | Middleman.ConfigContext.mime_type | train | def mime_type(type, value)
type = ".#{type}" unless type.to_s[0] == '.'
| ruby | {
"resource": ""
} |
q12181 | Middleman.ExtensionManager.activate | train | def activate(ext_name, options_hash = ::Middleman::EMPTY_HASH, &block)
begin
extension = ::Middleman::Extensions.load(ext_name)
rescue LoadError => e
logger.debug "== Failed Activation `#{ext_name}` : #{e.message}"
return
end
logger.debug "== Activating: #{ext_name}"
... | ruby | {
"resource": ""
} |
q12182 | Middleman.Application.apply_cli_options | train | def apply_cli_options
config[:cli_options].each do |k, v|
setting = config.setting(k.to_sym)
next unless setting
| ruby | {
"resource": ""
} |
q12183 | Middleman.Application.prune_tilt_templates! | train | def prune_tilt_templates!
mapping = ::Tilt.default_mapping
mapping.lazy_map.each_key do |key| | ruby | {
"resource": ""
} |
q12184 | Middleman::Cli.Extension.extension | train | def extension
copy_file 'extension/gitignore', File.join(name, '.gitignore') unless options[:'skip-git']
template 'extension/Rakefile', File.join(name, 'Rakefile')
template 'extension/gemspec', File.join(name, "#{name}.gemspec")
template 'extension/Gemfile', File.join(name, 'Gemfile')
temp... | ruby | {
"resource": ""
} |
q12185 | Middleman.Extension.add_exposed_to_context | train | def add_exposed_to_context(context)
(self.class.exposed_to_template || {}).each do |k, v|
| ruby | {
"resource": ""
} |
q12186 | Middleman::Cli.Init.init | train | def init
require 'fileutils'
require 'tmpdir'
unless git_present?
msg = 'You need to install the git command line tool to initialize a new project. '
msg << "For help installing git, please refer to GitHub's tutorial at https://help.github.com/articles/set-up-git"
say msg, :r... | ruby | {
"resource": ""
} |
q12187 | Middleman::Cli.Init.which | train | def which(executable)
if File.file?(executable) && File.executable?(executable)
executable
elsif ENV['PATH']
path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
abs_path = File.join(p, executable)
| ruby | {
"resource": ""
} |
q12188 | Middleman::Cli.Build.build | train | def build
root = ENV['MM_ROOT'] || Dir.pwd
raise Thor::Error, 'Error: Could not find a Middleman project config, perhaps you are in the wrong folder?' unless File.exist?(File.join(root, 'config.rb'))
require 'middleman-core'
require 'middleman-core/logger'
require 'middleman-core/builder... | ruby | {
"resource": ""
} |
q12189 | Middleman::Cli.Build.on_event | train | def on_event(event_type, target, extra = nil)
case event_type
when :error
say_status :error, target, :red
shell.say extra, :red if options['verbose'] || options['bail']
raise 'Build error' if options['bail']
when :deleted
say_status :remove, target, :green
when :... | ruby | {
"resource": ""
} |
q12190 | Middleman::Cli.Build.clean_directories! | train | def clean_directories!
all_build_files = File.join(@app.config[:build_dir], '**', '*')
empty_directories = Dir[all_build_files].select do |d|
File.directory?(d)
end | ruby | {
"resource": ""
} |
q12191 | Middleman.Rack.process_request | train | def process_request(env, req, res)
start_time = Time.now
request_path = URI.decode(env['PATH_INFO'].dup)
request_path.force_encoding('UTF-8') if request_path.respond_to? :force_encoding
request_path = ::Middleman::Util.full_path(request_path, @middleman)
full_request_path = File.join(env[... | ruby | {
"resource": ""
} |
q12192 | Middleman.Rack.not_found | train | def not_found(res, path)
path = ::Rack::Utils.escape_html(path)
res.status = 404
res.write | ruby | {
"resource": ""
} |
q12193 | Middleman.Rack.send_file | train | def send_file(resource, env)
file = ::Rack::File.new nil
path = resource.file_descriptor[:full_path]
if !file.respond_to?(:path=)
request = ::Rack::Request.new(env)
response = file.serving(request, path)
else
file.path = path
response = file.serving(env)
... | ruby | {
"resource": ""
} |
q12194 | Middleman::Cli.Server.server | train | def server
require 'middleman-core'
require 'middleman-core/preview_server'
unless ENV['MM_ROOT']
puts '== Could not find a Middleman project config.rb'
exit
end
params = {
debug: options['verbose'],
instrumenting: options['instrument'],
| ruby | {
"resource": ""
} |
q12195 | Middleman.TemplateContext.wrap_layout | train | def wrap_layout(layout_name, &block)
# Save current buffer for later
buf_was = save_buffer
# Find a layout for this file
layout_file = ::Middleman::TemplateRenderer.locate_layout(@app, layout_name, current_engine)
# Get the layout engine
extension = File.extname(layout_file[:relati... | ruby | {
"resource": ""
} |
q12196 | Middleman.TemplateContext.render_file | train | def render_file(file, locs, opts, &block)
_render_with_all_renderers(file[:relative_ | ruby | {
"resource": ""
} |
q12197 | Middleman.Util.glob_directory | train | def glob_directory(path)
results = ::Dir[path]
return results unless RUBY_PLATFORM =~ /darwin/
| ruby | {
"resource": ""
} |
q12198 | Razorpay.Request.create_instance | train | def create_instance(res)
response = res.parsed_response
# if there was an error, throw it
raise_error(response['error'], res.code) if response.nil? || response.key?('error')
# There must be a top level entity
# This is either one of payment, refund, or collection at present
begin
... | ruby | {
"resource": ""
} |
q12199 | AttrEncrypted.InstanceMethods.decrypt | train | def decrypt(attribute, encrypted_value)
encrypted_attributes[attribute.to_sym][:operation] = :decrypting
encrypted_attributes[attribute.to_sym][:value_present] | 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.