view release on metacpan or search on metacpan
lib/Alien/LibUSBx.pm view on Meta::CPAN
use 5.006;
use strict;
use warnings;
use parent 'Alien::Base';
=head1 NAME
Alien::LibUSBx - Alien package for libusb (libusb-1.0) which provides generic access to USB devices
view release on metacpan or search on metacpan
lib/Alien/LibXML.pm view on Meta::CPAN
package Alien::LibXML;
use strict;
use warnings;
use parent 'Alien::Base';
our $VERSION = '0.004';
__END__
=pod
view release on metacpan or search on metacpan
lib/Alien/Libarchive/Installer.pm view on Meta::CPAN
require File::Path;
File::Path::mkpath($pkg_config_dir, 0, 0755);
}
my($version) = map { /^Version:\s*(.*)$/; $1 } grep /^Version: /, @content;
# older versions apparently didn't include the necessary -I and -L flags
if(defined $version && $version =~ /^[12]\./)
{
for(@content)
{
s/^Libs: /Libs: -L\${libdir} /;
view release on metacpan or search on metacpan
xt/author/version.t view on Meta::CPAN
use YAML qw( LoadFile );
use FindBin;
use File::Spec;
plan skip_all => "test not built yet (run dzil test)"
unless -e dir( $FindBin::Bin)->parent->parent->file('Makefile.PL')
|| -e dir( $FindBin::Bin)->parent->parent->file('Build.PL');
my $config_filename = File::Spec->catfile(
$FindBin::Bin, File::Spec->updir, File::Spec->updir, 'author.yml'
);
view release on metacpan or search on metacpan
lib/Alien/Libasyncns.pm view on Meta::CPAN
package Alien::Libasyncns;
use strict;
use warnings;
use parent 'Alien::Base';
our $VERSION = '0.002';
1;
__END__
view release on metacpan or search on metacpan
lib/Alien/Libdogecoin.pm view on Meta::CPAN
package Alien::Libdogecoin;
# ABSTRACT: detect or install libdogecoin
use strict;
use warnings;
use parent 'Alien::Base';
our $VERSION = '0.1.1.1';
1;
view release on metacpan or search on metacpan
lib/Alien/Libgcrypt.pm view on Meta::CPAN
use 5.006;
use strict;
use warnings;
use parent 'Alien::Base';
1;
=head1 NAME
view release on metacpan or search on metacpan
libjio/tests/behaviour/tf.py view on Meta::CPAN
if pid == 0:
# child
f(*args, **kwargs)
sys.exit(0)
else:
# parent
id, status = os.waitpid(pid, 0)
if not os.WIFEXITED(status):
raise RuntimeError, (id, status)
def forked(f):
view release on metacpan or search on metacpan
lib/Alien/Librdkafka.pm view on Meta::CPAN
package Alien::Librdkafka;
use strict;
use warnings;
use parent 'Alien::Base';
our $VERSION = '0.11.6';
=head1 NAME
Alien::Librdkafka - build and install librdkafka
view release on metacpan or search on metacpan
if( -l '/opt/local/bin/openssl' ) {
my $dir = Path::Tiny->new(readlink '/opt/local/bin/openssl');
$dir = $dir->relative('/opt/local/bin') if $dir->is_relative;
$dir = $dir
->parent
->parent
->child('lib')
->child('pkgconfig');
push @PKG_CONFIG_LIBDIR, "$dir";
}
log "overidding PKG_CONFIG_LIBDIR on macOS: $ENV{PKG_CONFIG_LIBDIR}";
}
if($^O eq 'MSWin32' && $Config{myuname} =~ /strawberry-?perl 5\.([0-9]+)\./ && $1 < 20)
{
my $libdir = Path::Tiny->new($^X)->parent->parent->parent->child('c/lib');
# older versions of Straberry didn't have a working pkg-config
plugin 'Probe::CBuilder' => (
libs => $_,
version => qr/version = \|(.*?)\|/,
program => <<'EOF',
view release on metacpan or search on metacpan
lib/Alien/Libtensorflow.pm view on Meta::CPAN
# LICENSE: Apache_2_0
$Alien::Libtensorflow::VERSION = '0.002';
use strict;
use warnings;
use parent qw(Alien::Base);
1;
__END__
view release on metacpan or search on metacpan
lib/Alien/Lua.pm view on Meta::CPAN
package Alien::Lua;
use 5.14.0;
use warnings;
our $VERSION = '5.2.2.2';
use parent 'Alien::Base';
our $CanUseLuaJIT;
BEGIN {
$CanUseLuaJIT = 0;
eval "require Alien::LuaJIT"
view release on metacpan or search on metacpan
lib/Alien/LuaJIT.pm view on Meta::CPAN
package Alien::LuaJIT;
use 5.14.0;
use warnings;
our $VERSION = '2.0.2.1';
use parent 'Alien::Base';
1;
__END__
=head1 NAME
view release on metacpan or search on metacpan
}
}
if(my $uname_exe = which('uname'))
{
my $bin_dir = path($uname_exe)->parent->stringify;
my $uname = `$uname_exe`;
if($uname =~ /^(MSYS|MINGW(32|64))_NT/ && msys_is_okay($bin_dir)) {
$build->runtime_prop->{my_type} = 'found uname in PATH';
$build->runtime_prop->{my_bin} = $bin_dir;
return 'system';
}
}
if(my $mingw_get = which('mingw-get.exe'))
{
my $bin_dir = path($mingw_get)->parent->parent->child('msys/1.0/bin')->stringify;
if(msys_is_okay($bin_dir))
{
$build->runtime_prop->{my_type} = 'relative to mingw-get.exe';
$build->runtime_prop->{my_bin} = $bin_dir;
return 'system';
my $lnk_name = path(Win32::GetFolderPath(Win32::CSIDL_DESKTOP(), 1))->child('MinGW Installer.lnk')->canonpath;
die "No MinGW Installer.lnk" unless -r $lnk_name;
my $lnk = Win32::Shortcut->new;
$lnk->Load($lnk_name);
my $mingw_get = path($lnk->{Path});
my $bin_dir = path($mingw_get)->parent->child('msys/1.0/bin');
if(msys_is_okay($bin_dir))
{
$build->runtime_prop->{my_type} = 'MinGW Installer shortcut';
$build->runtime_prop->{my_bin} = $bin_dir;
return 'system';
view release on metacpan or search on metacpan
lib/Alien/Moot.pm view on Meta::CPAN
package Alien::Moot;
use strict;
use warnings;
use parent 'Alien::Base';
our $VERSION = '0.003';
__END__
=pod
view release on metacpan or search on metacpan
lib/Alien/MuPDF.pm view on Meta::CPAN
package Alien::MuPDF;
$Alien::MuPDF::VERSION = '0.012';
use strict;
use warnings;
use parent qw(Alien::Base);
use File::Spec;
sub mutool_path {
my ($self) = @_;
File::Spec->catfile( File::Spec->rel2abs($self->dist_dir) , 'bin', 'mutool' );
view release on metacpan or search on metacpan
inc/Alien/NSS/ModuleBuild.pm view on Meta::CPAN
package Alien::NSS::ModuleBuild;
use parent 'Alien::Base::ModuleBuild';
# remove libnssckbi.dylib because at least on os-x it cannot be linked...
sub alien_generate_manual_pkgconfig {
my $self = shift;
view release on metacpan or search on metacpan
lib/Alien/OTR.pm view on Meta::CPAN
our $AUTHORITY = 'cpan:AJGB';
$Alien::OTR::VERSION = '4.1.1.0';
use Alien::GCrypt;
use Alien::GPG::Error;
use parent 'Alien::Base';
1;
__END__
view release on metacpan or search on metacpan
lib/Alien/OpenMP.pm view on Meta::CPAN
package Alien::OpenMP;
use parent 'Alien::Base';
use Config ();
use Alien::OpenMP::configure ();
our $VERSION = '0.003006';
view release on metacpan or search on metacpan
lib/Alien/OpenSSL/Static.pm view on Meta::CPAN
package Alien::OpenSSL::Static;
use parent 'Alien::Base';
our $VERSION = '1.000001';
=head1 NAME
Alien::OpenSSL::Static - Alien wrapper for OpenSSL
view release on metacpan or search on metacpan
if( -l '/opt/local/bin/openssl' ) {
require Path::Tiny;
my $dir = Path::Tiny->new(readlink '/opt/local/bin/openssl');
$dir = $dir->relative('/opt/local/bin') if $dir->is_relative;
$dir = $dir
->parent
->parent
->child('lib')
->child('pkgconfig');
push @PKG_CONFIG_LIBDIR, "$dir";
}
view release on metacpan or search on metacpan
lib/Alien/OpenVcdiff.pm view on Meta::CPAN
package Alien::OpenVcdiff;
our $VERSION = '0.101';
use parent 'Alien::Base';
use strict;
sub vcdiff_binary {
my $dist_dir = Alien::OpenVcdiff->dist_dir();
view release on metacpan or search on metacpan
sys {
after 'gather' => sub {
my ( $build) = @_;
if ( defined( my $exe = which( 'pgxwin_server' ) ) ) {
$build->runtime_prop->{system_bin_dir} = path($exe)->parent->stringify;
}
};
}
view release on metacpan or search on metacpan
lib/Alien/Plotly/Kaleido.pm view on Meta::CPAN
use strict;
use warnings;
our $VERSION = '0.003'; # VERSION
use parent 'Alien::Base';
use File::Which qw(which);
use IPC::Run ();
use JSON ();
use Path::Tiny ();
view release on metacpan or search on metacpan
lib/Alien/Plotly/Orca.pm view on Meta::CPAN
use strict;
use warnings;
our $VERSION = '0.0002'; # VERSION
use parent 'Alien::Base';
1;
__END__
view release on metacpan or search on metacpan
lib/Alien/Proj4.pm view on Meta::CPAN
package Alien::Proj4;
use strict;
use warnings;
use parent qw( Alien::Base );
our $VERSION = '2.019113';
# most of the following are for compat with PDLA Makefiles
# and should not be used by other code
view release on metacpan or search on metacpan
inc/AP/Build.pm view on Meta::CPAN
package AP::Build;
use strict;
use warnings;
use parent 'Alien::Base::ModuleBuild';
use ExtUtils::CBuilder;
use ExtUtils::CppGuess;
sub new {
view release on metacpan or search on metacpan
prototype.js view on Meta::CPAN
Prototype.BrowserFeatures.XPath = false;
/* Based on Alex Arnell's inheritance implementation. */
var Class = {
create: function() {
var parent = null, properties = $A(arguments);
if (Object.isFunction(properties[0]))
parent = properties.shift();
function klass() {
this.initialize.apply(this, arguments);
}
Object.extend(klass, Class.Methods);
klass.superclass = parent;
klass.subclasses = [];
if (parent) {
var subclass = function() { };
subclass.prototype = parent.prototype;
klass.prototype = new subclass;
parent.subclasses.push(klass);
}
for (var i = 0; i < properties.length; i++)
klass.addMethods(properties[i]);
prototype.js view on Meta::CPAN
element = document.getElementById(element);
return Element.extend(element);
}
if (Prototype.BrowserFeatures.XPath) {
document._getElementsByXPath = function(expression, parentElement) {
var results = [];
var query = document.evaluate(expression, $(parentElement) || document,
null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
for (var i = 0, length = query.snapshotLength; i < length; i++)
results.push(Element.extend(query.snapshotItem(i)));
return results;
};
prototype.js view on Meta::CPAN
return element;
},
remove: function(element) {
element = $(element);
element.parentNode.removeChild(element);
return element;
},
update: function(element, content) {
element = $(element);
prototype.js view on Meta::CPAN
var range = element.ownerDocument.createRange();
range.selectNode(element);
content.evalScripts.bind(content).defer();
content = range.createContextualFragment(content.stripScripts());
}
element.parentNode.replaceChild(content, element);
return element;
},
insert: function(element, insertions) {
element = $(element);
prototype.js view on Meta::CPAN
element = $(element);
if (Object.isElement(wrapper))
$(wrapper).writeAttribute(attributes || { });
else if (Object.isString(wrapper)) wrapper = new Element(wrapper, attributes);
else wrapper = new Element('div', wrapper);
if (element.parentNode)
element.parentNode.replaceChild(wrapper, element);
wrapper.appendChild(element);
return wrapper;
},
inspect: function(element) {
prototype.js view on Meta::CPAN
elements.push(Element.extend(element));
return elements;
},
ancestors: function(element) {
return $(element).recursivelyCollect('parentNode');
},
descendants: function(element) {
return $A($(element).getElementsByTagName('*')).each(Element.extend);
},
prototype.js view on Meta::CPAN
return selector.match($(element));
},
up: function(element, expression, index) {
element = $(element);
if (arguments.length == 1) return $(element.parentNode);
var ancestors = element.ancestors();
return expression ? Selector.findElement(ancestors, expression, index) :
ancestors[index || 0];
},
prototype.js view on Meta::CPAN
return Selector.findChildElements(element, args);
},
adjacent: function() {
var args = $A(arguments), element = $(args.shift());
return Selector.findChildElements(element.parentNode, args).without(element);
},
identify: function(element) {
element = $(element);
var id = element.readAttribute('id'), self = arguments.callee;
prototype.js view on Meta::CPAN
if (element.sourceIndex && !Prototype.Browser.Opera) {
var e = element.sourceIndex, a = ancestor.sourceIndex,
nextAncestor = ancestor.nextSibling;
if (!nextAncestor) {
do { ancestor = ancestor.parentNode; }
while (!(nextAncestor = ancestor.nextSibling) && ancestor.parentNode);
}
if (nextAncestor) return (e > a && e < nextAncestor.sourceIndex);
}
while (element = element.parentNode)
if (element == ancestor) return true;
return false;
},
scrollTo: function(element) {
prototype.js view on Meta::CPAN
cumulativeScrollOffset: function(element) {
var valueT = 0, valueL = 0;
do {
valueT += element.scrollTop || 0;
valueL += element.scrollLeft || 0;
element = element.parentNode;
} while (element);
return Element._returnOffset(valueL, valueT);
},
getOffsetParent: function(element) {
if (element.offsetParent) return $(element.offsetParent);
if (element == document.body) return $(element);
while ((element = element.parentNode) && element != document.body)
if (Element.getStyle(element, 'position') != 'static')
return $(element);
return $(document.body);
},
prototype.js view on Meta::CPAN
do {
if (!Prototype.Browser.Opera || element.tagName == 'BODY') {
valueT -= element.scrollTop || 0;
valueL -= element.scrollLeft || 0;
}
} while (element = element.parentNode);
return Element._returnOffset(valueL, valueT);
},
clonePosition: function(element, source) {
prototype.js view on Meta::CPAN
var p = source.viewportOffset();
// find coordinate system to use
element = $(element);
var delta = [0, 0];
var parent = null;
// delta [0,0] will do fine with position: fixed elements,
// position:absolute needs offsetParent deltas
if (Element.getStyle(element, 'position') == 'absolute') {
parent = element.getOffsetParent();
delta = parent.viewportOffset();
}
// correct by body offsets (fixes Safari)
if (parent == document.body) {
delta[0] -= document.body.offsetLeft;
delta[1] -= document.body.offsetTop;
}
// set position
prototype.js view on Meta::CPAN
continue;
}
content = Object.toHTML(content);
tagName = ((position == 'before' || position == 'after')
? element.parentNode : element).tagName.toUpperCase();
if (t.tags[tagName]) {
var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
if (position == 'top' || position == 'after') fragments.reverse();
fragments.each(pos.insert.curry(element));
prototype.js view on Meta::CPAN
Element.Methods.replace = function(element, content) {
element = $(element);
if (content && content.toElement) content = content.toElement();
if (Object.isElement(content)) {
element.parentNode.replaceChild(content, element);
return element;
}
content = Object.toHTML(content);
var parent = element.parentNode, tagName = parent.tagName.toUpperCase();
if (Element._insertionTranslations.tags[tagName]) {
var nextSibling = element.next();
var fragments = Element._getContentFromAnonymousElement(tagName, content.stripScripts());
parent.removeChild(element);
if (nextSibling)
fragments.each(function(node) { parent.insertBefore(node, nextSibling) });
else
fragments.each(function(node) { parent.appendChild(node) });
}
else element.outerHTML = content.stripScripts();
content.evalScripts.bind(content).defer();
return element;
prototype.js view on Meta::CPAN
Element._insertionTranslations = {
before: {
adjacency: 'beforeBegin',
insert: function(element, node) {
element.parentNode.insertBefore(node, element);
},
initializeRange: function(element, range) {
range.setStartBefore(element);
}
},
prototype.js view on Meta::CPAN
}
},
after: {
adjacency: 'afterEnd',
insert: function(element, node) {
element.parentNode.insertBefore(node, element.nextSibling);
},
initializeRange: function(element, range) {
range.setStartAfter(element);
}
},
prototype.js view on Meta::CPAN
},
// mark each child node with its position (for nth calls)
// "ofType" flag indicates whether we're indexing for nth-of-type
// rather than nth-child
index: function(parentNode, reverse, ofType) {
parentNode._counted = true;
if (reverse) {
for (var nodes = parentNode.childNodes, i = nodes.length - 1, j = 1; i >= 0; i--) {
var node = nodes[i];
if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
}
} else {
for (var i = 0, j = 1, nodes = parentNode.childNodes; node = nodes[i]; i++)
if (node.nodeType == 1 && (!ofType || node._counted)) node.nodeIndex = j++;
}
},
// filters out duplicates and extends all nodes
prototype.js view on Meta::CPAN
if (!nodes && root == document) return [targetNode];
if (nodes) {
if (combinator) {
if (combinator == 'child') {
for (var i = 0, node; node = nodes[i]; i++)
if (targetNode.parentNode == node) return [targetNode];
} else if (combinator == 'descendant') {
for (var i = 0, node; node = nodes[i]; i++)
if (Element.descendantOf(targetNode, node)) return [targetNode];
} else if (combinator == 'adjacent') {
for (var i = 0, node; node = nodes[i]; i++)
prototype.js view on Meta::CPAN
if (formula == 'even') formula = '2n+0';
if (formula == 'odd') formula = '2n+1';
var h = Selector.handlers, results = [], indexed = [], m;
h.mark(nodes);
for (var i = 0, node; node = nodes[i]; i++) {
if (!node.parentNode._counted) {
h.index(node.parentNode, reverse, ofType);
indexed.push(node.parentNode);
}
}
if (formula.match(/^\d+$/)) { // just a number
formula = Number(formula);
for (var i = 0, node; node = nodes[i]; i++)
prototype.js view on Meta::CPAN
isMiddleClick: function(event) { return isButton(event, 1) },
isRightClick: function(event) { return isButton(event, 2) },
element: function(event) {
var node = Event.extend(event).target;
return Element.extend(node.nodeType == Node.TEXT_NODE ? node.parentNode : node);
},
findElement: function(event, expression) {
var element = Event.element(event);
return element.match(expression) ? element : element.up(expression);
prototype.js view on Meta::CPAN
elements.push(Element.extend(child));
}
return elements;
};
return function(className, parentElement) {
return $(parentElement || document.body).getElementsByClassName(className);
};
}(Element.Methods);
/*--------------------------------------------------------------------------*/