def dropConstraint(table: String, constraint: String): Unit =
update(s"alter table $table drop constraint if exists $constraint")
def dropAllFkeys(): Unit = {
val found =
select("constraint_name, table_name from information_schema.table_constraints where constraint_schema='public' and constraint_type = 'FOREIGN KEY'") strings
for ((k::t::_) <- found) dropConstraint(t, k)
}
![[livejournal.com profile]](https://www.dreamwidth.org/img/external/lj-userinfo.gif){kind=small}
lomeo
def groupByRelationship[T](xs: List[T])(p: (T,T) => Boolean) = {
def go(xs: List[T], accum: List[List[T]]): List[List[T]] = (xs, accum) match {
case (Nil, _) => accum.reverse map (_.reverse)
case (x::xs, Nil) => go(xs, List(List(x)))
case (x::xs, ((ys@(y::_))::rest)) => go(xs, if (p(y, x)) (x::ys)::rest else
List(x)::ys::rest)
}
go(xs, Nil)
}
def groupByRelationship[T](p: (T,T) => Boolean)(xs: List[T]) = {
val (seg,acc) = ((List[T](),List[List[T]]()) /: xs) {
case ((y::ys, a), x) if p(y,x) => (x ::y ::ys, a)
case ( (ys, a), x) => (x::Nil, ys.reverse::a)
}
(seg.reverse::acc).reverse drop 1
}
def groupByRelationship[T](p: ((T,T) => Boolean)) = {
new (List[T] => List[List[T]]) { group =>
def apply(xs: List[T]): List[List[T]] =
xs match {
case Nil => Nil
case x::Nil => (x::Nil)::Nil
case x::y::tail if x == y || p(x,y) =>
val (h::t) = group(y::tail)
(x::h)::t
case x::ys => (x::Nil)::group(ys)
}
}
}
def groupByRelationship[T](p: ((T,T) => Boolean)) = {
new (List[T] => List[List[T]]) { group =>
def apply(xs: List[T]): List[List[T]] =
xs match {
case Nil => Nil
case x::Nil => (x::Nil)::Nil
case x::ys =>
val tail = group(ys)
if (x == ys.head || p(x, ys.head)) (x::tail.head)::tail.tail
else (x::Nil)::tail
}
}
}
lomeo, huzhepidarasa, cousin_it, sassa_nf for their critique.
Good("huilo") filter ((s:String) => s.startsWith("he"), "oi vei") must_== Result.error("oi vei")
override def getEOBs: Outcome = {
import JavaScript._
val outcome =
for (_ ← clickElementHavingText("a", "My Stuff") onError suspiciousError;
_ ← waitSelector("input#continue");
_ ← clickElementHavingText("input[name=dateRangeSelection]", "past year");
_ ← findElement("input[name=selectedMembers]");
_ ← js(s"$foundElement.checked = true");
_ ← clickElementHavingText("input#continue", "");
_ ← clickElementHavingText("a", "INTERNET.com");
_ ← findElementContainingText("*", "Processed");
_ ← clickElementHavingText("a", "More");
_ ← clickElementHavingText("input", "View All");
(contents, source) <- pageContents.toResultKeepingSource) yield {
println(contents.toFormattedString)
jsREPL("So?")
}
debug(s"Got $outcome"); OK
}
Result[Props], so the props contain all the information I managed to extract from the page.Result class.val List(_, median, _) = List(a,b,c).sorted
// I dedicate all this code, all my work,
// to my wife, Darlene, who will
// have to support me and our three
// children and the dog once it gets
// released into the public.
// Magic. Do not touch.
// this comment included for the benefit of
// anyone grepping for swearwords: shit.
// I am not responsible of this code.
// They made me write it, against my will.
// no comments for you
// it was hard to write
// so it should be hard to read
/* Be a real daemon: fork myself and kill my parent */
// I don't understand how the following bit works,
// but it worked in the program I stole it from.
// Dear maintainer:
// Once you are done trying to 'optimize' this routine,
// and have realized what a terrible mistake that was,
// please increment the following counter as a warning
// to the next guy:
// total_hours_wasted_here = 42
client execute {operation} inSession(username, password). That's how it should be.
client.execute {
session => {
val response = session.send(fileInfo)
info(s"Attachment - $fileInfo sent: $response")
response
}
} inSession(username, password)
def execute[T](op:ApiSession => Result[T]) = new {
def inSession(name:String, password:String): Result[T] = {
login(name, password) flatMap { s =>
try op(s) finally s.close
}
}
}
case class ApiSession(private val id: String, private val client: APIclient) {
def close() = client.get(s"logout?session=$id")
def send(fileInfo: FileInfo) = fileInfo.send(client)(id)
}
class EobHandling_Test extends Specification with MoreExpectations {
val handler = new EobHandling with MockDB {
override def pat_ins: Patient_ins = new MockPatientIns(42, Some(2))
}
"existsInDB" should {
"say 'no' if eob id is missing" in {
}
"say 'no' if eob is not in db" in {
}
"say 'yes' if one such eob is in db" in {
}
"say 'yes' if more than one such eob is in db" in {
}
}
}
s"[[$i]]" -> arrayValue(i)'.') inside keys, we can "flatten" the map of maps of maps, just by merging keys.
{"a" -> {
"key1" -> {
"[[0]]" -> "value at a.key1[0]"
...
}
}
}
{"a.key1.[[0]]" -> "value at a.key1[0]"
...
}
s/"\""/"""/g, we can get rid of quotes in keys and have only delimiting quotes in values.
type NoResult = Result[Nothing]
case object Empty extends NoResult with NoGood[Nothing] {
...
(_:_)
.onError((_:_) => savePage())
def using[T](file:File)(f: FileInputStream => T): Try[T] = Try {
val in = new FileInputStream(file)
(Try(f(in)), Try(in.close))._1
}.flatten
def startsWith(prefix: Array[Byte])(file: File):Boolean =
using (file) (in => prefix forall (in.read ==)) filter identity isSuccess
using that takes a file, then takes a function that converts a stream into something, opens the file, feeds the stream to the function, then always closes the file, returning a failure something went wrong.
type Outcome = Result[Any]
val OK:Outcome = Good("OK")
def executeJS(js: String): Result[Unit] = runJS(js) map asScala filter
("OK"==, wrong => s"Wrong response from browser: <<$wrong>>")
![[personal profile]](https://www.dreamwidth.org/img/silk/identity/user.png){kind=small}
timeasmymeasure