text:
set -euo pipefail
# --- begin runfiles.bash initialization ---
if [[ ! -d "${RUNFILES_DIR:-/dev/null}" && ! -f "${RUNFILES_MANIFEST_FILE:-/dev/null}" ]]; then
  if [[ -f "$0.runfiles_manifest" ]]; then
    export RUNFILES_MANIFEST_FILE="$0.runfiles_manifest"
  elif [[ -f "$0.runfiles/MANIFEST" ]]; then
    export RUNFILES_MANIFEST_FILE="$0.runfiles/MANIFEST"
  elif [[ -f "$0.runfiles/bazel_tools/tools/bash/runfiles/runfiles.bash" ]]; then
    export RUNFILES_DIR="$0.runfiles"
  fi
fi
if [[ -f "${RUNFILES_DIR:-/dev/null}/bazel_tools/tools/bash/runfiles/runfiles.bash" ]]; then
  source "${RUNFILES_DIR}/bazel_tools/tools/bash/runfiles/runfiles.bash"
elif [[ -f "${RUNFILES_MANIFEST_FILE:-/dev/null}" ]]; then
  source "$(grep -m1 "^bazel_tools/tools/bash/runfiles/runfiles.bash " \
            "$RUNFILES_MANIFEST_FILE" | cut -d ' ' -f 2-)"
else
  echo >&2 "ERROR: cannot find @bazel_tools//tools/bash/runfiles:runfiles.bash"
  exit 1
fi
# --- end runfiles.bash initialization ---

source "$(rlocation "io_bazel/src/test/shell/integration_test_setup.sh")" \
  || { echo "integration_test_setup.sh not found!" >&2; exit 1; }

# `uname` returns the current platform, e.g "MSYS_NT-10.0" or "Linux".
# `tr` converts all upper case letters to lower case.
# `case` matches the result if the `uname | tr` expression to string prefixes
# that use the same wildcards as names do in Bash, i.e. "msys*" matches strings
# starting with "msys", and "*" matches everything (it's the default case).
case "$(uname -s | tr [:upper:] [:lower:])" in
msys*)
  # As of 2019-01-15, Bazel on Windows only supports MSYS Bash.
  declare -r is_windows=true
  ;;
*)
  declare -r is_windows=false
  ;;
esac

if $is_windows; then
  export MSYS_NO_PATHCONV=1
  export MSYS2_ARG_CONV_EXCL="*"
  # Enable symlink runfiles tree to make bazel run work
  add_to_bazelrc "build --enable_runfiles"
fi

# Global test setup.
#
# Unpacks the test Git repositories in the test temporary directory.
function set_up() {
  bazel clean --expunge
  local repos_dir=$TEST_TMPDIR/repos
  if [ -e "$repos_dir" ]; then
    rm -rf $repos_dir
  fi

  mkdir -p $repos_dir
  cp "$(rlocation io_bazel/src/test/shell/bazel/testdata/pluto-repo.tar.gz)" $repos_dir
  cp "$(rlocation io_bazel/src/test/shell/bazel/testdata/outer-planets-repo.tar.gz)" $repos_dir
  cp "$(rlocation io_bazel/src/test/shell/bazel/testdata/refetch-repo.tar.gz)" $repos_dir
  cd $repos_dir
  tar zxf pluto-repo.tar.gz
  tar zxf outer-planets-repo.tar.gz
  tar zxf refetch-repo.tar.gz
}

# Test cloning a Git repository using the git_repository rule.
#
# This test uses the pluto Git repository at tag 1-build, which contains the
# following files:
#
# pluto/
#   WORKSPACE
#   BUILD
#   info
#
# Then, set up workspace with the following files:
#
# $WORKSPACE_DIR/
#   WORKSPACE
#   planets/
#     BUILD
#     planet_info.sh
#
# //planets has a dependency on a target in the pluto Git repository.
function test_git_repository() {
  local pluto_repo_dir=$TEST_TMPDIR/repos/pluto
  # Commit corresponds to tag 1-build. See testdata/pluto.git_log.
  local commit_hash="52f9a3f87a2dd17ae0e5847bbae9734f09354afd"

  # Create a workspace that clones the repository at the first commit.
  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(
    name = "pluto",
    remote = "$pluto_repo_dir",
    commit = "$commit_hash",
)
EOF
  mkdir -p planets
  cat > planets/BUILD <<EOF
sh_binary(
    name = "planet-info",
    srcs = ["planet_info.sh"],
    data = ["@pluto//:pluto"],
)
EOF

  cat > planets/planet_info.sh <<EOF
#!/bin/sh
cat ../pluto/info
EOF
  chmod +x planets/planet_info.sh

  bazel run //planets:planet-info >& $TEST_log \
    || echo "Expected build/run to succeed"
  expect_log "Pluto is a dwarf planet"
}

function test_new_git_repository_with_build_file() {
  do_new_git_repository_test "build_file"
}

function test_new_git_repository_with_build_file_content() {
  do_new_git_repository_test "build_file_content"
}

# Test cloning a Git repository using the new_git_repository rule.
#
# This test uses the pluto Git repository at tag 0-initial, which contains the
# following files:
#
# pluto/
#   info
#
# Set up workspace with the following files:
#
# $WORKSPACE_DIR/
#   WORKSPACE
#   pluto.BUILD
#   planets/
#     BUILD
#     planet_info.sh
#
# //planets has a dependency on a target in the $TEST_TMPDIR/pluto Git
# repository.
function do_new_git_repository_test() {
  local pluto_repo_dir=$TEST_TMPDIR/repos/pluto

  # Create a workspace that clones the repository at the first commit.
  cd $WORKSPACE_DIR

  if [ "$1" == "build_file" ] ; then
    cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
new_git_repository(
    name = "pluto",
    remote = "$pluto_repo_dir",
    tag = "0-initial",
    build_file = "//:pluto.BUILD",
)
EOF
  cat > BUILD <<EOF
exports_files(['pluto.BUILD'])
EOF
    cat > pluto.BUILD <<EOF
filegroup(
    name = "pluto",
    srcs = ["info"],
    visibility = ["//visibility:public"],
)
EOF
  else
    cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
new_git_repository(
    name = "pluto",
    remote = "$pluto_repo_dir",
    tag = "0-initial",
    build_file_content = """
filegroup(
    name = "pluto",
    srcs = ["info"],
    visibility = ["//visibility:public"],
)"""
)
EOF
  fi

  mkdir -p planets
  cat > planets/BUILD <<EOF
sh_binary(
    name = "planet-info",
    srcs = ["planet_info.sh"],
    data = ["@pluto//:pluto"],
)
EOF

  cat > planets/planet_info.sh <<EOF
#!/bin/sh
cat ../pluto/info
EOF
  chmod +x planets/planet_info.sh

  bazel run //planets:planet-info >& $TEST_log \
    || echo "Expected build/run to succeed"
  expect_log "Pluto is a planet"
}

# Test cloning a Git repository that has a submodule using the
# new_git_repository rule.
#
# This test uses the outer-planets Git repository at revision 1-submodule, which
# contains the following files:
#
# outer_planets/
#   neptune/
#     info
#   pluto/  --> submodule ../pluto
#     info
#
# Set up workspace with the following files:
#
# $WORKSPACE_DIR/
#   WORKSPACE
#   outer_planets.BUILD
#   planets/
#     BUILD
#     planet_info.sh
#
# planets has a dependency on targets in the $TEST_TMPDIR/outer_planets Git
# repository.
function test_new_git_repository_submodules() {
  local outer_planets_repo_dir=$TEST_TMPDIR/repos/outer-planets

  # Create a workspace that clones the outer_planets repository.
  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "new_git_repository")
new_git_repository(
    name = "outer_planets",
    remote = "$outer_planets_repo_dir",
    tag = "1-submodule",
    init_submodules = 1,
    build_file = "//:outer_planets.BUILD",
)
EOF

  cat > BUILD <<EOF
exports_files(['outer_planets.BUILD'])
EOF
  cat > outer_planets.BUILD <<EOF
filegroup(
    name = "neptune",
    srcs = ["neptune/info"],
    visibility = ["//visibility:public"],
)

filegroup(
    name = "pluto",
    srcs = ["pluto/info"],
    visibility = ["//visibility:public"],
)
EOF

  mkdir -p planets
  cat > planets/BUILD <<EOF
sh_binary(
    name = "planet-info",
    srcs = ["planet_info.sh"],
    data = [
        "@outer_planets//:neptune",
        "@outer_planets//:pluto",
    ],
)
EOF

  cat > planets/planet_info.sh <<EOF
#!/bin/sh
cat ../outer_planets/neptune/info
cat ../outer_planets/pluto/info
EOF
  chmod +x planets/planet_info.sh

  bazel run //planets:planet-info >& $TEST_log \
    || echo "Expected build/run to succeed"
  expect_log "Neptune is a planet"
  expect_log "Pluto is a planet"
}

function test_git_repository_not_refetched_on_server_restart() {
  local repo_dir=$TEST_TMPDIR/repos/refetch

  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='22095302abaf776886879efa5129aa4d44c53017')
EOF

  # Use batch to force server restarts.
  bazel --batch build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 1" bazel-genfiles/external/g/go

  # Without changing anything, restart the server, which should not cause the checkout to be re-cloned.
  bazel --batch build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 1" bazel-genfiles/external/g/go

  # Change the commit id, which should cause the checkout to be re-cloned.
  rm WORKSPACE
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='db134ae9b644d8237954a8e6f1ef80fcfd85d521')
EOF

  bazel --batch build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 2" bazel-genfiles/external/g/go

  # Change the WORKSPACE but not the commit id, which should not cause the checkout to be re-cloned.
  rm WORKSPACE
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
# This comment line is to change the line numbers, which should not cause Bazel
# to refetch the repository
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='db134ae9b644d8237954a8e6f1ef80fcfd85d521')
EOF

  bazel --batch build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 2" bazel-genfiles/external/g/go
}

function test_git_repository_refetched_when_commit_changes() {
  local repo_dir=$TEST_TMPDIR/repos/refetch

  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='22095302abaf776886879efa5129aa4d44c53017')
EOF

  bazel build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 1" bazel-genfiles/external/g/go

  # Change the commit id, which should cause the checkout to be re-cloned.
  rm WORKSPACE
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='db134ae9b644d8237954a8e6f1ef80fcfd85d521')
EOF

  bazel build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 2" bazel-genfiles/external/g/go
}

function test_git_repository_and_nofetch() {
  local repo_dir=$TEST_TMPDIR/repos/refetch

  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='22095302abaf776886879efa5129aa4d44c53017')
EOF

  bazel build --nofetch @g//:g >& $TEST_log && fail "Build succeeded"
  expect_log "fetching repositories is disabled"
  bazel build @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 1" bazel-genfiles/external/g/go

  rm WORKSPACE
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(name='g', remote='$repo_dir', commit='db134ae9b644d8237954a8e6f1ef80fcfd85d521')
EOF

  bazel build --nofetch @g//:g >& $TEST_log || fail "Build failed"
  expect_log "External repository 'g' is not up-to-date"
  assert_contains "GIT 1" bazel-genfiles/external/g/go
  bazel build  @g//:g >& $TEST_log || fail "Build failed"
  assert_contains "GIT 2" bazel-genfiles/external/g/go
}

# Helper function for setting up the workspace as follows
#
# $WORKSPACE_DIR/
#   WORKSPACE
#   planets/
#     planet_info.sh
#     BUILD
function setup_error_test() {
  cd $WORKSPACE_DIR
  mkdir -p planets
  cat > planets/planet_info.sh <<EOF
#!/bin/sh
cat external/pluto/info
EOF

  cat > planets/BUILD <<EOF
sh_binary(
    name = "planet-info",
    srcs = ["planet_info.sh"],
    data = ["@pluto//:pluto"],
)
EOF
}

# Verifies that rule fails if both tag and commit are set.
#
# This test uses the pluto Git repository at tag 1-build, which contains the
# following files:
#
# pluto/
#   WORKSPACE
#   BUILD
#   info
function test_git_repository_both_commit_tag_error() {
  setup_error_test
  local pluto_repo_dir=$TEST_TMPDIR/pluto
  # Commit corresponds to tag 1-build. See testdata/pluto.git_log.
  local commit_hash="52f9a3f87a2dd17ae0e5847bbae9734f09354afd"

  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(
    name = "pluto",
    remote = "$pluto_repo_dir",
    tag = "1-build",
    commit = "$commit_hash",
)
EOF

  bazel fetch //planets:planet-info >& $TEST_log \
    || echo "Expect run to fail."
  expect_log "Exactly one of commit"
}

# Verifies that rule fails if neither tag or commit are set.
#
# This test uses the pluto Git repository at tag 1-build, which contains the
# following files:
#
# pluto/
#   WORKSPACE
#   BUILD
#   info
function test_git_repository_no_commit_tag_error() {
  setup_error_test
  local pluto_repo_dir=$TEST_TMPDIR/pluto

  cd $WORKSPACE_DIR
  cat >> $(create_workspace_with_default_repos WORKSPACE) <<EOF
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
git_repository(
    name = "pluto",
    remote = "$pluto_repo_dir",
)
EOF

  bazel fetch //planets:planet-info >& $TEST_log \
    || echo "Expect run to fail."
  expect_log "Exactly one of commit"
}

run_suite "git_repository tests"


text:
<?php

require_once 'securimage.php';

$t0         = microtime(true);

$securimage = new Securimage(array('no_exit' => true));
$securimage->use_database = true;
$securimage->database_driver = Securimage::SI_DRIVER_MYSQL;
$securimage->database_host   = 'localhost';
$securimage->database_user   = 'securimage';
$securimage->database_pass   = 'password1234';
$securimage->database_name   = 'test';

$securimage->show();

$t1         = microtime(true);

redpajama_set_name: RedPajamaGithub


text:
<?xml version='1.0' encoding='utf-8'?>
<plugin id="de.apparentmedia.cordova.native_ui_plugin" version="0.0.1" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
    <name>NativeUIPlugin</name>
    <js-module name="native-ui-plugin" src="www/native-ui-plugin.js">
        <clobbers target="cordova.plugins.native-ui-plugin" />
    </js-module>

    <!-- android -->
    <platform name="android">
        <config-file target="res/xml/config.xml" parent="/*">
            <feature name="native-ui-plugin" >
                <param name="android-package" value="de.apparentmedia.cordova.NativeUIPlugin"/>
            </feature>
        </config-file>

        <source-file src="src/android/NativeUIPlugin.java" target-dir="src/de/apparentmedia/cordova" />
    </platform>
</plugin>


text:
package com.gradle.exportapi.dao;

import static com.gradle.exportapi.dbutil.SQLHelper.*;

import com.gradle.exportapi.model.Build;
import org.knowm.yank.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.OffsetDateTime;
import java.time.ZoneId;

public class BuildDAO {

    static final Logger log = LoggerFactory.getLogger(BuildDAO.class);

    public static long insertBuild(Build build) {

        OffsetDateTime start = OffsetDateTime.ofInstant
                (build.getTimer().getStartTime(), ZoneId.of(build.getTimer().getTimeZoneId()));

        OffsetDateTime finish = OffsetDateTime.ofInstant
                (build.getTimer().getStartTime(), ZoneId.of(build.getTimer().getTimeZoneId()));

        Object[] params = new Object[] {
                build.getBuildId(),
                build.getUserName(),
                build.getRootProjectName(),
                start,
                finish,
                build.getStatus(),
                build.getTagsAsSingleString()
        };

        String SQL = insert("builds (build_id, user_name, root_project_name, start, finish, status, tags)", params);
        Long generatedid= Yank.insert(SQL, params);
        if(generatedid == 0) {
            throw new RuntimeException("Unable to save build record for " + build.getBuildId());
        }
        return generatedid;
    }

    public static String findLastBuildId() {
        String sql = "select build_id from builds where id in (select max(id) from builds);";
        Build build = Yank.queryBean(sql, Build.class, new Object[0] );
        return build !=null ? build.getBuildId() : null;
    }
}


text:
package ro.pub.cs.aipi.lab06.general;

import java.util.Calendar;
import java.util.GregorianCalendar;
import javax.xml.datatype.XMLGregorianCalendar;

public class Utilities {

    public static String convertGregorianCalendarToString(GregorianCalendar date) {
        return date.get(Calendar.DAY_OF_MONTH)+"/"+date.get(Calendar.MONTH)+"/"+date.get(Calendar.YEAR)+" "+date.get(Calendar.HOUR_OF_DAY)+":"+date.get(Calendar.MINUTE);
    }

    public static String convertGregorianCalendarToString(XMLGregorianCalendar date) {
        return date.getDay()+"/"+(date.getMonth()-1)+"/"+date.getYear()+" "+date.getHour()+":"+date.getMinute();
    }

}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Bot. Jb. 56: 719 (1921)

#### Original name
Bispora opuntiicola Reichert

### Remarks
null


text:
package api

import (
	"testing"
)

func TestJsonContentType(t *testing.T) {
	if !MatchesContentType("application/json", "application/json") {
		t.Fail()
	}

	if !MatchesContentType("application/json; charset=utf-8", "application/json") {
		t.Fail()
	}

	if MatchesContentType("dockerapplication/json", "application/json") {
		t.Fail()
	}
}


text:
using System;
using System.IO;
using PassWinmenu.ExternalPrograms;

namespace PassWinmenuTests.Utilities
{
	public class FakeProcess : IProcess
	{

		public void Kill()
		{
		}

		public bool WaitForExit(TimeSpan timeout)
		{
			return ExitTime < timeout;
		}

		public StreamWriter StandardInput { get; set; } = new StreamWriter(Stream.Null);
		public StreamReader StandardOutput { get; set; } = new StreamReader(Stream.Null);
		public StreamReader StandardError { get; set; } = new StreamReader(Stream.Null);
		public string MainModuleName { get; } = string.Empty;
		public int Id { get; } = 1;
		public DateTime StartTime { get; } = DateTime.Now;
		public int ExitCode { get; set; } = 0;

		public TimeSpan ExitTime { get; set; }
	}
}


text:
export class BCHTxProvder {
  lib = require('bitcore-lib-cash');
  create({ recipients, utxos, change, fee }) {
    let tx = new this.lib.Transaction().from(utxos).fee(Number(fee));
    for (const recipient of recipients) {
      tx.to(recipient.address, recipient.amount);
    }
    if (change) {
      tx.change(change);
    }
    return tx;
  }
}
export default new BCHTxProvder();


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

 <meta>

  <link href="../web.css" type="text/css" rel="stylesheet"></link>
  <link href="../pygmentize.css" type="text/css" rel="stylesheet"></link>
  <title>VLFeat - Documentation - Matlab API - VL_SETUP</title>

 </meta>

   <form action="http://www.vlfeat.org/search.html" method="get" id="cse-search-box" enctype="application/x-www-form-urlencoded">

     <input type="hidden" name="cx" value="003215582122030917471:oq23albfeam"></input>
     <input type="hidden" name="cof" value="FORID:11"></input>
     <input type="hidden" name="ie" value="UTF-8"></input>
     <input type="text" name="q" size="31"></input>
     <input type="submit" name="sa" value="Search"></input>

   </form>

VLFeat.org

   Documentation - Matlab API - VL_SETUP

Home

Download

Documentation

Matlab API

C API

Man pages

Tutorials

Applications

Index

Prev

Next

PATH = VL_SETUP() adds the VLFeat Toolbox to MATLAB path and
returns the path PATH to the VLFeat package.

VL_SETUP('NOPREFIX') adds aliases to each function that do not
contain the VL_ prefix. For example, with this option it is
possible to use SIFT() instead of VL_SIFT().

VL_SETUP('TEST') or VL_SETUP('XTEST') adds VLFeat unit test
function suite. See also VL_TEST().

VL_SETUP('QUIET') does not print the greeting message.

See also: VL_ROOT(), VL_HELP().

   © 2005-11 Andrea Vedaldi and Brian Fulkerson


text:
package com.sksamuel.elastic4s.aws

import com.amazonaws.auth._
import org.scalatest.{Matchers, WordSpec}

class Aws4RequestSignerTest extends WordSpec with Matchers with SharedTestData {

  "Aws4RequestSigner" should {

    val result =
      """AWS4-HMAC-SHA256 Credential=AKIDEXAMPLE/20150830/us-east-1/es/aws4_request, SignedHeaders=content-type;host;x-amz-date, Signature=6aab780be5a6c06d0a7cc4528756dae4394e3c99b5d81bd4b07a745ab5a90735""".stripMargin

    "be able to add amazon compliant authentication header" in {

      val chainProvider = new AWSStaticCredentialsProvider(new BasicAWSCredentials(awsKey, awsSecret))
      val signer = new Aws4TestRequestSigner(chainProvider, region, date, dateTime)
      val withHeaders = signer.withAws4Headers(httpPostRequest)
      withHeaders.getAllHeaders find (_.getName == "Authorization") match {
        case Some(header) ⇒ header.getValue shouldBe (result)
        case _            ⇒ 1 shouldBe (0)
      }
    }

    "be able to add security Token Header if there is a session key in context" in {
      val credentials = new BasicSessionCredentials(awsKey, awsSecret, awsSessionToken)
      val chainProvider = new AWSStaticCredentialsProvider(credentials)
      val signer = new Aws4TestRequestSigner(chainProvider, region, date, dateTime)
      val withHeaders = signer.withAws4Headers(httpPostRequest)
      withHeaders.getAllHeaders find (_.getName == "X-Amz-Security-Token") match {
        case Some(header) ⇒ header.getValue shouldBe (awsSessionToken)
        case _            ⇒ 1 shouldBe (0)
      }
    }

    "be able to add date time header when none is found" in {
      val credentials = new BasicSessionCredentials(awsKey, awsSecret, awsSessionToken)
      val chainProvider = new AWSStaticCredentialsProvider(credentials)
      val signer = new Aws4TestRequestSigner(chainProvider, region, date, dateTime)

      val withHeaders = signer.withAws4Headers(httpPostRequestWithoutDate)
      withHeaders.getAllHeaders find (_.getName == "Authorization") match {
        case Some(header) ⇒ header.getValue shouldBe (result)
        case _            ⇒ 1 shouldBe (0)
      }
    }

    "be able to clean bad Host headers" in {
      val credentials = new BasicSessionCredentials(awsKey, awsSecret, awsSessionToken)
      val chainProvider = new AWSStaticCredentialsProvider(credentials)
      val signer = new Aws4TestRequestSigner(chainProvider, region, date, dateTime)

      val withHeaders = signer.withAws4Headers(httpPostRequestWithBadHost)
      withHeaders.getAllHeaders find (_.getName == "Authorization") match {
        case Some(header) ⇒ header.getValue shouldBe (result)
        case _            ⇒ 1 shouldBe (0)
      }
    }
  }

  class Aws4TestRequestSigner(awsCredentialProvider: AWSCredentialsProvider, region: String, date: String, dateTime: String)
    extends Aws4RequestSigner(awsCredentialProvider, region) {
    override def buildDateAndDateTime() = (date, dateTime)
  }

}


text:
package pgproto3

import (
	"bytes"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
)

// Frontend acts as a client for the PostgreSQL wire protocol version 3.
type Frontend struct {
	cr *chunkReader
	w  io.Writer

	// tracer is used to trace messages when Send or Receive is called. This means an outbound message is traced
	// before it is actually transmitted (i.e. before Flush). It is safe to change this variable when the Frontend is
	// idle. Setting and unsetting tracer provides equivalent functionality to PQtrace and PQuntrace in libpq.
	tracer *tracer

	wbuf []byte

	// Backend message flyweights
	authenticationOk                AuthenticationOk
	authenticationCleartextPassword AuthenticationCleartextPassword
	authenticationMD5Password       AuthenticationMD5Password
	authenticationGSS               AuthenticationGSS
	authenticationGSSContinue       AuthenticationGSSContinue
	authenticationSASL              AuthenticationSASL
	authenticationSASLContinue      AuthenticationSASLContinue
	authenticationSASLFinal         AuthenticationSASLFinal
	backendKeyData                  BackendKeyData
	bindComplete                    BindComplete
	closeComplete                   CloseComplete
	commandComplete                 CommandComplete
	copyBothResponse                CopyBothResponse
	copyData                        CopyData
	copyInResponse                  CopyInResponse
	copyOutResponse                 CopyOutResponse
	copyDone                        CopyDone
	dataRow                         DataRow
	emptyQueryResponse              EmptyQueryResponse
	errorResponse                   ErrorResponse
	functionCallResponse            FunctionCallResponse
	noData                          NoData
	noticeResponse                  NoticeResponse
	notificationResponse            NotificationResponse
	parameterDescription            ParameterDescription
	parameterStatus                 ParameterStatus
	parseComplete                   ParseComplete
	readyForQuery                   ReadyForQuery
	rowDescription                  RowDescription
	portalSuspended                 PortalSuspended

	bodyLen    int
	msgType    byte
	partialMsg bool
	authType   uint32
}

// NewFrontend creates a new Frontend.
func NewFrontend(r io.Reader, w io.Writer) *Frontend {
	cr := newChunkReader(r, 0)
	return &Frontend{cr: cr, w: w}
}

// Send sends a message to the backend (i.e. the server). The message is not guaranteed to be written until Flush is
// called.
//
// Send can work with any FrontendMessage. Some commonly used message types such as Bind have specialized send methods
// such as SendBind. These methods should be preferred when the type of message is known up front (e.g. when building an
// extended query protocol query) as they may be faster due to knowing the type of msg rather than it being hidden
// behind an interface.
func (f *Frontend) Send(msg FrontendMessage) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceMessage('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// Flush writes any pending messages to the backend (i.e. the server).
func (f *Frontend) Flush() error {
	if len(f.wbuf) == 0 {
		return nil
	}

	n, err := f.w.Write(f.wbuf)

	const maxLen = 1024
	if len(f.wbuf) > maxLen {
		f.wbuf = make([]byte, 0, maxLen)
	} else {
		f.wbuf = f.wbuf[:0]
	}

	if err != nil {
		return &writeError{err: err, safeToRetry: n == 0}
	}

	return nil
}

// Trace starts tracing the message traffic to w. It writes in a similar format to that produced by the libpq function
// PQtrace.
func (f *Frontend) Trace(w io.Writer, options TracerOptions) {
	f.tracer = &tracer{
		w:             w,
		buf:           &bytes.Buffer{},
		TracerOptions: options,
	}
}

// Untrace stops tracing.
func (f *Frontend) Untrace() {
	f.tracer = nil
}

// SendBind sends a Bind message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendBind(msg *Bind) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceBind('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendParse sends a Parse message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendParse(msg *Parse) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceParse('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendClose sends a Close message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendClose(msg *Close) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceClose('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendDescribe sends a Describe message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendDescribe(msg *Describe) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceDescribe('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendExecute sends a Execute message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendExecute(msg *Execute) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.TraceQueryute('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendSync sends a Sync message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendSync(msg *Sync) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceSync('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendQuery sends a Query message to the backend (i.e. the server). The message is not guaranteed to be written until
// Flush is called.
func (f *Frontend) SendQuery(msg *Query) {
	prevLen := len(f.wbuf)
	f.wbuf = msg.Encode(f.wbuf)
	if f.tracer != nil {
		f.tracer.traceQuery('F', int32(len(f.wbuf)-prevLen), msg)
	}
}

// SendUnbufferedEncodedCopyData immediately sends an encoded CopyData message to the backend (i.e. the server). This method
// is more efficient than sending a CopyData message with Send as the message data is not copied to the internal buffer
// before being written out. The internal buffer is flushed before the message is sent.
func (f *Frontend) SendUnbufferedEncodedCopyData(msg []byte) error {
	err := f.Flush()
	if err != nil {
		return err
	}

	n, err := f.w.Write(msg)
	if err != nil {
		return &writeError{err: err, safeToRetry: n == 0}
	}

	if f.tracer != nil {
		f.tracer.traceCopyData('F', int32(len(msg)-1), &CopyData{})
	}

	return nil
}

func translateEOFtoErrUnexpectedEOF(err error) error {
	if err == io.EOF {
		return io.ErrUnexpectedEOF
	}
	return err
}

// Receive receives a message from the backend. The returned message is only valid until the next call to Receive.
func (f *Frontend) Receive() (BackendMessage, error) {
	if !f.partialMsg {
		header, err := f.cr.Next(5)
		if err != nil {
			return nil, translateEOFtoErrUnexpectedEOF(err)
		}

		f.msgType = header[0]

		msgLength := int(binary.BigEndian.Uint32(header[1:]))
		if msgLength < 4 {
			return nil, fmt.Errorf("invalid message length: %d", msgLength)
		}

		f.bodyLen = msgLength - 4
		f.partialMsg = true
	}

	msgBody, err := f.cr.Next(f.bodyLen)
	if err != nil {
		return nil, translateEOFtoErrUnexpectedEOF(err)
	}

	f.partialMsg = false

	var msg BackendMessage
	switch f.msgType {
	case '1':
		msg = &f.parseComplete
	case '2':
		msg = &f.bindComplete
	case '3':
		msg = &f.closeComplete
	case 'A':
		msg = &f.notificationResponse
	case 'c':
		msg = &f.copyDone
	case 'C':
		msg = &f.commandComplete
	case 'd':
		msg = &f.copyData
	case 'D':
		msg = &f.dataRow
	case 'E':
		msg = &f.errorResponse
	case 'G':
		msg = &f.copyInResponse
	case 'H':
		msg = &f.copyOutResponse
	case 'I':
		msg = &f.emptyQueryResponse
	case 'K':
		msg = &f.backendKeyData
	case 'n':
		msg = &f.noData
	case 'N':
		msg = &f.noticeResponse
	case 'R':
		var err error
		msg, err = f.findAuthenticationMessageType(msgBody)
		if err != nil {
			return nil, err
		}
	case 's':
		msg = &f.portalSuspended
	case 'S':
		msg = &f.parameterStatus
	case 't':
		msg = &f.parameterDescription
	case 'T':
		msg = &f.rowDescription
	case 'V':
		msg = &f.functionCallResponse
	case 'W':
		msg = &f.copyBothResponse
	case 'Z':
		msg = &f.readyForQuery
	default:
		return nil, fmt.Errorf("unknown message type: %c", f.msgType)
	}

	err = msg.Decode(msgBody)
	if err != nil {
		return nil, err
	}

	if f.tracer != nil {
		f.tracer.traceMessage('B', int32(5+len(msgBody)), msg)
	}

	return msg, nil
}

// Authentication message type constants.
// See src/include/libpq/pqcomm.h for all
// constants.
const (
	AuthTypeOk                = 0
	AuthTypeCleartextPassword = 3
	AuthTypeMD5Password       = 5
	AuthTypeSCMCreds          = 6
	AuthTypeGSS               = 7
	AuthTypeGSSCont           = 8
	AuthTypeSSPI              = 9
	AuthTypeSASL              = 10
	AuthTypeSASLContinue      = 11
	AuthTypeSASLFinal         = 12
)

func (f *Frontend) findAuthenticationMessageType(src []byte) (BackendMessage, error) {
	if len(src) < 4 {
		return nil, errors.New("authentication message too short")
	}
	f.authType = binary.BigEndian.Uint32(src[:4])

	switch f.authType {
	case AuthTypeOk:
		return &f.authenticationOk, nil
	case AuthTypeCleartextPassword:
		return &f.authenticationCleartextPassword, nil
	case AuthTypeMD5Password:
		return &f.authenticationMD5Password, nil
	case AuthTypeSCMCreds:
		return nil, errors.New("AuthTypeSCMCreds is unimplemented")
	case AuthTypeGSS:
		return &f.authenticationGSS, nil
	case AuthTypeGSSCont:
		return &f.authenticationGSSContinue, nil
	case AuthTypeSSPI:
		return nil, errors.New("AuthTypeSSPI is unimplemented")
	case AuthTypeSASL:
		return &f.authenticationSASL, nil
	case AuthTypeSASLContinue:
		return &f.authenticationSASLContinue, nil
	case AuthTypeSASLFinal:
		return &f.authenticationSASLFinal, nil
	default:
		return nil, fmt.Errorf("unknown authentication type: %d", f.authType)
	}
}

// GetAuthType returns the authType used in the current state of the frontend.
// See SetAuthType for more information.
func (f *Frontend) GetAuthType() uint32 {
	return f.authType
}


text:
/* An abstract class for the "basic" views, as well as month view. Renders one or more rows of day cells.
----------------------------------------------------------------------------------------------------------------------*/
// It is a manager for a DayGrid subcomponent, which does most of the heavy lifting.
// It is responsible for managing width/height.

var BasicView = View.extend({

	dayGrid: null, // the main subcomponent that does most of the heavy lifting

	dayNumbersVisible: false, // display day numbers on each day cell?
	weekNumbersVisible: false, // display week numbers along the side?

	weekNumberWidth: null, // width of all the week-number cells running down the side

	headRowEl: null, // the fake row element of the day-of-week header

	initialize: function() {
		this.dayGrid = new DayGrid(this);
		this.coordMap = this.dayGrid.coordMap; // the view's date-to-cell mapping is identical to the subcomponent's
	},

	// Sets the display range and computes all necessary dates
	setRange: function(range) {
		View.prototype.setRange.call(this, range); // call the super-method

		this.dayGrid.breakOnWeeks = /year|month|week/.test(this.intervalUnit); // do before setRange
		this.dayGrid.setRange(range);
	},

	// Compute the value to feed into setRange. Overrides superclass.
	computeRange: function(date) {
		var range = View.prototype.computeRange.call(this, date); // get value from the super-method

		// year and month views should be aligned with weeks. this is already done for week
		if (/year|month/.test(range.intervalUnit)) {
			range.start.startOf('week');
			range.start = this.skipHiddenDays(range.start);

			// make end-of-week if not already
			if (range.end.weekday()) {
				range.end.add(1, 'week').startOf('week');
				range.end = this.skipHiddenDays(range.end, -1, true); // exclusively move backwards
			}
		}

		return range;
	},

	// Renders the view into `this.el`, which should already be assigned
	renderDates: function() {

		this.dayNumbersVisible = this.dayGrid.rowCnt > 1; // TODO: make grid responsible
		this.weekNumbersVisible = this.opt('weekNumbers');
		this.dayGrid.numbersVisible = this.dayNumbersVisible || this.weekNumbersVisible;

		this.el.addClass('fc-basic-view').html(this.renderHtml());

		this.headRowEl = this.el.find('thead .fc-row');

		this.scrollerEl = this.el.find('.fc-day-grid-container');
		this.dayGrid.coordMap.containerEl = this.scrollerEl; // constrain clicks/etc to the dimensions of the scroller

		this.dayGrid.setElement(this.el.find('.fc-day-grid'));
		this.dayGrid.renderDates(this.hasRigidRows());
	},

	// Unrenders the content of the view. Since we haven't separated skeleton rendering from date rendering,
	// always completely kill the dayGrid's rendering.
	unrenderDates: function() {
		this.dayGrid.unrenderDates();
		this.dayGrid.removeElement();
	},

	renderBusinessHours: function() {
		this.dayGrid.renderBusinessHours();
	},

	// Builds the HTML skeleton for the view.
	// The day-grid component will render inside of a container defined by this HTML.
	renderHtml: function() {
		return '' +
			'
' +
				'
' +
					'
' +
						'' +
							this.dayGrid.headHtml() + // render the day-of-week headers
						'	' +
					'
' +
				'
' +
				'
' +
					'
' +
						'' +
							'
' +
								'
' +
							'
' +
						'	' +
					'
' +
				'
' +
			'
';
	},

	// Generates the HTML that will go before the day-of week header cells.
	// Queried by the DayGrid subcomponent when generating rows. Ordering depends on isRTL.
	headIntroHtml: function() {
		if (this.weekNumbersVisible) {
			return '' +
				'' +
					'' + // needed for matchCellWidths
						htmlEscape(this.opt('weekNumberTitle')) +
					'' +
				'	';
		}
	},

	// Generates the HTML that will go before content-skeleton cells that display the day/week numbers.
	// Queried by the DayGrid subcomponent. Ordering depends on isRTL.
	numberIntroHtml: function(row) {
		if (this.weekNumbersVisible) {
			return '' +
				'' +
					'' + // needed for matchCellWidths
						this.dayGrid.getCell(row, 0).start.format('w') +
					'' +
				'	';
		}
	},

	// Generates the HTML that goes before the day bg cells for each day-row.
	// Queried by the DayGrid subcomponent. Ordering depends on isRTL.
	dayIntroHtml: function() {
		if (this.weekNumbersVisible) {
			return '	';
		}
	},

	// Generates the HTML that goes before every other type of row generated by DayGrid. Ordering depends on isRTL.
	// Affects helper-skeleton and highlight-skeleton rows.
	introHtml: function() {
		if (this.weekNumbersVisible) {
			return '	';
		}
	},

	// Generates the HTML for the s of the "number" row in the DayGrid's content skeleton.
	// The number row will only exist if either day numbers or week numbers are turned on.
	numberCellHtml: function(cell) {
		var date = cell.start;
		var classes;

		if (!this.dayNumbersVisible) { // if there are week numbers but not day numbers
			return ''; //  will create an empty space above events :(
		}

		classes = this.dayGrid.getDayClasses(date);
		classes.unshift('fc-day-number');

		return '' +
			'' +
				date.date() +
			'	';
	},

	// Generates an HTML attribute string for setting the width of the week number column, if it is known
	weekNumberStyleAttr: function() {
		if (this.weekNumberWidth !== null) {
			return 'style="width:' + this.weekNumberWidth + 'px"';
		}
		return '';
	},

	// Determines whether each row should have a constant height
	hasRigidRows: function() {
		var eventLimit = this.opt('eventLimit');
		return eventLimit && typeof eventLimit !== 'number';
	},

	/* Dimensions
	------------------------------------------------------------------------------------------------------------------*/

	// Refreshes the horizontal dimensions of the view
	updateWidth: function() {
		if (this.weekNumbersVisible) {
			// Make sure all week number cells running down the side have the same width.
			// Record the width for cells created later.
			this.weekNumberWidth = matchCellWidths(
				this.el.find('.fc-week-number')
			);
		}
	},

	// Adjusts the vertical dimensions of the view to the specified values
	setHeight: function(totalHeight, isAuto) {
		var eventLimit = this.opt('eventLimit');
		var scrollerHeight;

		// reset all heights to be natural
		unsetScroller(this.scrollerEl);
		uncompensateScroll(this.headRowEl);

		this.dayGrid.removeSegPopover(); // kill the "more" popover if displayed

		// is the event limit a constant level number?
		if (eventLimit && typeof eventLimit === 'number') {
			this.dayGrid.limitRows(eventLimit); // limit the levels first so the height can redistribute after
		}

		scrollerHeight = this.computeScrollerHeight(totalHeight);
		this.setGridHeight(scrollerHeight, isAuto);

		// is the event limit dynamically calculated?
		if (eventLimit && typeof eventLimit !== 'number') {
			this.dayGrid.limitRows(eventLimit); // limit the levels after the grid's row heights have been set
		}

		if (!isAuto && setPotentialScroller(this.scrollerEl, scrollerHeight)) { // using scrollbars?

			compensateScroll(this.headRowEl, getScrollbarWidths(this.scrollerEl));

			// doing the scrollbar compensation might have created text overflow which created more height. redo
			scrollerHeight = this.computeScrollerHeight(totalHeight);
			this.scrollerEl.height(scrollerHeight);
		}
	},

	// Sets the height of just the DayGrid component in this view
	setGridHeight: function(height, isAuto) {
		if (isAuto) {
			undistributeHeight(this.dayGrid.rowEls); // let the rows be their natural height with no expanding
		}
		else {
			distributeHeight(this.dayGrid.rowEls, height, true); // true = compensate for height-hogging rows
		}
	},

	/* Events
	------------------------------------------------------------------------------------------------------------------*/

	// Renders the given events onto the view and populates the segments array
	renderEvents: function(events) {
		this.dayGrid.renderEvents(events);

		this.updateHeight(); // must compensate for events that overflow the row
	},

	// Retrieves all segment objects that are rendered in the view
	getEventSegs: function() {
		return this.dayGrid.getEventSegs();
	},

	// Unrenders all event elements and clears internal segment data
	unrenderEvents: function() {
		this.dayGrid.unrenderEvents();

		// we DON'T need to call updateHeight() because:
		// A) a renderEvents() call always happens after this, which will eventually call updateHeight()
		// B) in IE8, this causes a flash whenever events are rerendered
	},

	/* Dragging (for both events and external elements)
	------------------------------------------------------------------------------------------------------------------*/

	// A returned value of `true` signals that a mock "helper" event has been rendered.
	renderDrag: function(dropLocation, seg) {
		return this.dayGrid.renderDrag(dropLocation, seg);
	},

	unrenderDrag: function() {
		this.dayGrid.unrenderDrag();
	},

	/* Selection
	------------------------------------------------------------------------------------------------------------------*/

	// Renders a visual indication of a selection
	renderSelection: function(range) {
		this.dayGrid.renderSelection(range);
	},

	// Unrenders a visual indications of a selection
	unrenderSelection: function() {
		this.dayGrid.unrenderSelection();
	}

});


text:
'use strict';

// Load modules

const Hapi = require('hapi');
const Hoek = require('hoek');
const Bell = require('../');

const server = new Hapi.Server();
server.connection({ port: 8000 });

server.register(Bell, (err) => {

    Hoek.assert(!err, err);
    server.auth.strategy('discord', 'bell', {
        provider: 'discord',
        password: 'cookie_encryption_password_secure',
        isSecure: false,
        // Fill in your clientId and clientSecret: https://discordapp.com/developers/applications/me
        clientId: '',
        clientSecret: ''
    });

    server.route({
        method: '*',
        path: '/bell/door',
        config: {
            auth: 'discord',
            handler: function (request, reply) {

                reply('<pre>' + JSON.stringify(request.auth.credentials, null, 4) + '</pre>');
            }
        }
    });

    server.start((err) => {

        Hoek.assert(!err, err);
        console.log('Server started at:', server.info.uri);
    });
});


text:
// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu-framework/master/LICENCE

using osu.Framework.Input;
using OpenTK.Input;

namespace osu.Framework.Graphics.Containers
{
    /// <summary>
    /// An element which starts hidden and can be toggled to visible.
    /// </summary>
    public abstract class OverlayContainer : VisibilityContainer
    {
        /// <summary>
        /// Whether we should automatically hide on the user pressing escape.
        /// </summary>
        protected virtual bool HideOnEscape => true;

        /// <summary>
        /// Whether we should block any mouse input from interacting with things behind us.
        /// </summary>
        protected virtual bool BlockPassThroughMouse => true;

        /// <summary>
        /// Whether we should block any keyboard input from interacting with things behind us.
        /// </summary>
        protected virtual bool BlockPassThroughKeyboard => false;

        protected override bool OnHover(InputState state) => BlockPassThroughMouse;

        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => BlockPassThroughMouse;

        protected override bool OnClick(InputState state) => BlockPassThroughMouse;

        protected override bool OnDragStart(InputState state) => BlockPassThroughMouse;

        protected override bool OnWheel(InputState state) => BlockPassThroughMouse;

        protected override bool OnKeyDown(InputState state, KeyDownEventArgs args)
        {
            switch (args.Key)
            {
                case Key.Escape:
                    if (State == Visibility.Hidden || !HideOnEscape) return false;
                    Hide();
                    return true;
            }

            return BlockPassThroughKeyboard;
        }

        protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => BlockPassThroughKeyboard;
    }

    public enum Visibility
    {
        Hidden,
        Visible
    }
}


text:
ChangeLog
=========

Unreleased
----------

2.2.0 - (March 6, 2018)
------------------
### Removed
* Removed props-table script from package.json

2.1.0 - (February 26, 2018)
------------------
### Changed
* Reduced erroneous default margin-right value of 2rem
* Add theming variable to native-input margin-top when is-mobile

2.0.1 - (February 13, 2018)
------------------
### Changed
* Updated peerDependencies

2.0.0 - (February 12, 2018)
------------------
### Changed
* Updated to use React 16
* Update theming values to initial browser default for various properties
* Merged border-color, border-width, and border-style into short-hand syntax

1.2.0 - (February 1, 2018)
------------------
### Changed
* Minor version bump

1.1.0 - (January 18, 2018)
------------------
### Added
* Unchecked state transition

### Removed
* Select-container css class

### Changed
* Increase padding on mobile resize
* Focus styling: from box-shadow to border-width and border-color

1.0.0 - (January 5, 2018)
------------------
Initial release


text:
/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */

#ifndef _WX_COMPILER_H_
#define _WX_COMPILER_H_

/*
    Compiler detection and related helpers.
 */

/*
    Notice that Intel compiler can be used as Microsoft Visual C++ add-on and
    so we should define both __INTELC__ and __VISUALC__ for it.
*/
#ifdef __INTEL_COMPILER
#   define __INTELC__
#endif

#if defined(_MSC_VER)
    /*
       define another standard symbol for Microsoft Visual C++: the standard
       one (_MSC_VER) is also defined by some other compilers.
     */
#   define __VISUALC__ _MSC_VER

    /*
      define special symbols for different VC version instead of writing tests
      for magic numbers such as 1200, 1300 &c repeatedly
    */
#if __VISUALC__ < 1100
#   error "This Visual C++ version is too old and not supported any longer."
#elif __VISUALC__ < 1200
#   define __VISUALC5__
#elif __VISUALC__ < 1300
#   define __VISUALC6__
#elif __VISUALC__ < 1400
#   define __VISUALC7__
#elif __VISUALC__ < 1500
#   define __VISUALC8__
#elif __VISUALC__ < 1600
#   define __VISUALC9__
#elif __VISUALC__ < 1700
#   define __VISUALC10__
#elif __VISUALC__ < 1800
#   define __VISUALC11__
#elif __VISUALC__ < 1900
#   define __VISUALC12__
#else
#   pragma message("Please update wx/compiler.h to recognize this VC++ version")
#endif

#elif defined(__BCPLUSPLUS__) && !defined(__BORLANDC__)
#   define __BORLANDC__
#elif defined(__WATCOMC__)
#elif defined(__SC__)
#   define __SYMANTECC__
#elif defined(__SUNPRO_CC)
#   ifndef __SUNCC__
#       define __SUNCC__ __SUNPRO_CC
#   endif /* Sun CC */
#elif defined(__SC__)
#    ifdef __DMC__
#         define __DIGITALMARS__
#    else
#         define __SYMANTEC__
#    endif
#endif  /* compiler */

/*
   Macros for checking compiler version.
*/

/*
   This macro can be used to test the gcc version and can be used like this:

#    if wxCHECK_GCC_VERSION(3, 1)
        ... we have gcc 3.1 or later ...
#    else
        ... no gcc at all or gcc < 3.1 ...
#    endif
*/
#if defined(__GNUC__) && defined(__GNUC_MINOR__)
    #define wxCHECK_GCC_VERSION( major, minor ) \
        ( ( __GNUC__ > (major) ) \
            || ( __GNUC__ == (major) && __GNUC_MINOR__ >= (minor) ) )
#else
    #define wxCHECK_GCC_VERSION( major, minor ) 0
#endif

/*
   This macro can be used to test the Visual C++ version.
*/
#ifndef __VISUALC__
#   define wxVISUALC_VERSION(major) 0
#   define wxCHECK_VISUALC_VERSION(major) 0
#else
#   define wxVISUALC_VERSION(major) ( (6 + major) * 100 )
#   define wxCHECK_VISUALC_VERSION(major) ( __VISUALC__ >= wxVISUALC_VERSION(major) )
#endif

/**
    This is similar to wxCHECK_GCC_VERSION but for Sun CC compiler.
 */
#ifdef __SUNCC__
    /*
       __SUNCC__ is 0xVRP where V is major version, R release and P patch level
     */
    #define wxCHECK_SUNCC_VERSION(maj, min) (__SUNCC__ >= (((maj)<<8) | ((min)<<4)))
#else
    #define wxCHECK_SUNCC_VERSION(maj, min) (0)
#endif

#ifndef __WATCOMC__
#   define wxWATCOM_VERSION(major,minor) 0
#   define wxCHECK_WATCOM_VERSION(major,minor) 0
#   define wxONLY_WATCOM_EARLIER_THAN(major,minor) 0
#   define WX_WATCOM_ONLY_CODE( x )
#else
#   if __WATCOMC__ < 1200
#       error "Only Open Watcom is supported in this release"
#   endif

#   define wxWATCOM_VERSION(major,minor) ( major * 100 + minor * 10 + 1100 )
#   define wxCHECK_WATCOM_VERSION(major,minor) ( __WATCOMC__ >= wxWATCOM_VERSION(major,minor) )
#   define wxONLY_WATCOM_EARLIER_THAN(major,minor) ( __WATCOMC__ < wxWATCOM_VERSION(major,minor) )
#   define WX_WATCOM_ONLY_CODE( x )  x
#endif

/*
   This macro can be used to check that the version of mingw32 CRT is at least
   maj.min
 */

/*
    Define Mingw identification symbols, wxCHECK_MINGW32_VERSION() is defined in
    wx/msw/gccpriv.h which is included later, see comments there.
 */
#ifdef __MINGW32__
/*
    MinGW-w64 project provides compilers for both Win32 and Win64 but only
    defines the same __MINGW32__ symbol for the former as MinGW32 toolchain
    which is quite different (notably doesn't provide many SDK headers that
    MinGW-w64 does include). So we define a separate symbol which, unlike the
    predefined __MINGW64__, can be used to detect this toolchain in both 32 and
    64 bit builds.

    And define __MINGW32_TOOLCHAIN__ for consistency and also because it's
    convenient as we often want to have some workarounds only for the (old)
    MinGW32 but not (newer) MinGW-w64, which still predefines __MINGW32__.
 */
#   ifdef __MINGW64_VERSION_MAJOR
#       ifndef __MINGW64_TOOLCHAIN__
#           define __MINGW64_TOOLCHAIN__
#       endif
#   else
#       ifndef __MINGW32_TOOLCHAIN__
#           define __MINGW32_TOOLCHAIN__
#       endif
#   endif
#endif

#endif // _WX_COMPILER_H_


text:
package client

import (
	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/testclient"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
)

type FakeAction testclient.FakeAction

// Fake implements Interface. Meant to be embedded into a struct to get a default
// implementation. This makes faking out just the method you want to test easier.
type Fake struct {
	// Fake by default keeps a simple list of the methods that have been called.
	Actions []FakeAction
	Err     error
	// ReactFn is an optional function that will be invoked with the provided action
	// and return a response.
	ReactFn testclient.ReactionFunc
}

func (c *Fake) Invokes(action FakeAction, obj runtime.Object) (runtime.Object, error) {
	c.Actions = append(c.Actions, action)
	if c.ReactFn != nil {
		return c.ReactFn(testclient.FakeAction(action))
	}
	return obj, c.Err
}

var _ Interface = &Fake{}

func (c *Fake) Builds(namespace string) BuildInterface {
	return &FakeBuilds{Fake: c, Namespace: namespace}
}

func (c *Fake) BuildConfigs(namespace string) BuildConfigInterface {
	return &FakeBuildConfigs{Fake: c, Namespace: namespace}
}

func (c *Fake) BuildLogs(namespace string) BuildLogsInterface {
	return &FakeBuildLogs{Fake: c, Namespace: namespace}
}

func (c *Fake) Images() ImageInterface {
	return &FakeImages{Fake: c}
}

func (c *Fake) ImageRepositories(namespace string) ImageRepositoryInterface {
	return &FakeImageRepositories{Fake: c, Namespace: namespace}
}

func (c *Fake) ImageRepositoryMappings(namespace string) ImageRepositoryMappingInterface {
	return &FakeImageRepositoryMappings{Fake: c, Namespace: namespace}
}

func (c *Fake) ImageRepositoryTags(namespace string) ImageRepositoryTagInterface {
	return &FakeImageRepositoryTags{Fake: c, Namespace: namespace}
}

func (c *Fake) ImageStreams(namespace string) ImageStreamInterface {
	return &FakeImageStreams{Fake: c, Namespace: namespace}
}

func (c *Fake) ImageStreamMappings(namespace string) ImageStreamMappingInterface {
	return &FakeImageStreamMappings{Fake: c, Namespace: namespace}
}

func (c *Fake) ImageStreamTags(namespace string) ImageStreamTagInterface {
	return &FakeImageStreamTags{Fake: c, Namespace: namespace}
}

func (c *Fake) ImageStreamImages(namespace string) ImageStreamImageInterface {
	return &FakeImageStreamImages{Fake: c, Namespace: namespace}
}

func (c *Fake) Deployments(namespace string) DeploymentInterface {
	return &FakeDeployments{Fake: c, Namespace: namespace}
}

func (c *Fake) DeploymentConfigs(namespace string) DeploymentConfigInterface {
	return &FakeDeploymentConfigs{Fake: c, Namespace: namespace}
}

func (c *Fake) Routes(namespace string) RouteInterface {
	return &FakeRoutes{Fake: c, Namespace: namespace}
}

func (c *Fake) Templates(namespace string) TemplateInterface {
	return &FakeTemplates{Fake: c}
}

func (c *Fake) TemplateConfigs(namespace string) TemplateConfigInterface {
	return &FakeTemplateConfigs{Fake: c}
}

func (c *Fake) Identities() IdentityInterface {
	return &FakeIdentities{Fake: c}
}

func (c *Fake) Users() UserInterface {
	return &FakeUsers{Fake: c}
}

func (c *Fake) UserIdentityMappings() UserIdentityMappingInterface {
	return &FakeUserIdentityMappings{Fake: c}
}

func (c *Fake) Projects() ProjectInterface {
	return &FakeProjects{Fake: c}
}

func (c *Fake) ProjectRequests() ProjectRequestInterface {
	return &FakeProjectRequests{Fake: c}
}

func (c *Fake) Policies(namespace string) PolicyInterface {
	return &FakePolicies{Fake: c}
}

func (c *Fake) Roles(namespace string) RoleInterface {
	return &FakeRoles{Fake: c}
}

func (c *Fake) RoleBindings(namespace string) RoleBindingInterface {
	return &FakeRoleBindings{Fake: c}
}

func (c *Fake) PolicyBindings(namespace string) PolicyBindingInterface {
	return &FakePolicyBindings{Fake: c}
}

func (c *Fake) ResourceAccessReviews(namespace string) ResourceAccessReviewInterface {
	return &FakeResourceAccessReviews{Fake: c}
}

func (c *Fake) RootResourceAccessReviews() ResourceAccessReviewInterface {
	return &FakeRootResourceAccessReviews{Fake: c}
}

func (c *Fake) SubjectAccessReviews(namespace string) SubjectAccessReviewInterface {
	return &FakeSubjectAccessReviews{Fake: c}
}


text:
.. class:: YoutubeField

    The :code:`YoutubeField` type extends the Django `CharField <https://docs.djangoproject.com/en/1.11/ref/forms/fields/#charfield>`_,
    but automatically adds a :ref:`YoutubeValidator <gn-django-youtube-validator>`


text:
//
//  SLSMoleculeDownloadViewController.m
//  Molecules
//
//  The source code for Molecules is available under a BSD license.  See License.txt for details.
//
//  Created by Brad Larson on 7/2/2008.
//
//  This controller manages the pop-up modal view for downloading new molecules from the Protein Data Bank

#import "SLSMoleculeDownloadViewController.h"

@implementation SLSMoleculeDownloadViewController

- (id)initWithPDBCode:(NSString *)pdbCode andTitle:(NSString *)title;
{
	if (self = [super initWithNibName:@"SLSMoleculeDownloadView" bundle:nil])
	{
		// Initialization code
		downloadedFileContents = nil;
		downloadCancelled = NO;

		codeForCurrentlyDownloadingProtein = [pdbCode copy];
		titleForCurrentlyDownloadingProtein = [title copy];
		self.title = codeForCurrentlyDownloadingProtein;

	}
	return self;
}

- (void)dealloc;
{
	self.pdbDownloadDisplayView = nil;
	self.pdbInformationWebView = nil;
	self.moleculeTitleText = nil;
	self.downloadStatusText = nil;
	self.pdbInformationDisplayButton = nil;
	self.pdbDownloadButton = nil;
	self.downloadStatusBar = nil;
	self.indefiniteDownloadIndicator = nil;
	self.pdbCodeSearchWebView = nil;
	self.webLoadingLabel = nil;
	self.webLoadingIndicator = nil;

	[self cancelDownload];
	[codeForCurrentlyDownloadingProtein release];
	[titleForCurrentlyDownloadingProtein release];
	[pdbDownloadButton release];
	[super dealloc];

}
/*
 Implement loadView if you want to create a view hierarchy programmatically
- (void)loadView {
}
 */

- (void)viewDidLoad
{
	[self.view addSubview:pdbDownloadDisplayView];
	[indefiniteDownloadIndicator stopAnimating];
	indefiniteDownloadIndicator.hidden = YES;

	[pdbDownloadDisplayView setBackgroundColor:[UIColor groupTableViewBackgroundColor]];

	moleculeTitleText.text = titleForCurrentlyDownloadingProtein;

	// Set up the green download button
	pdbDownloadButton = [[UIButton alloc] initWithFrame:CGRectMake(36, 212, 247, 37)];

	pdbDownloadButton.contentVerticalAlignment = UIControlContentVerticalAlignmentCenter;
	pdbDownloadButton.contentHorizontalAlignment = UIControlContentHorizontalAlignmentCenter;

	[pdbDownloadButton setTitle:NSLocalizedStringFromTable(@"Download", @"Localized", nil) forState:UIControlStateNormal];
	[pdbDownloadButton setTitleColor:[UIColor whiteColor] forState:UIControlStateNormal];
	//[pdbDownloadButton setFont:[UIFont boldSystemFontOfSize:14.0]];

	UIImage *newImage = [[UIImage imageNamed:@"greenButton.png"] stretchableImageWithLeftCapWidth:12.0f topCapHeight:0.0f];
	[pdbDownloadButton setBackgroundImage:newImage forState:UIControlStateNormal];

	[pdbDownloadButton addTarget:self action:@selector(downloadNewProtein) forControlEvents:UIControlEventTouchDown];

    // in case the parent view draws with a custom color or gradient, use a transparent color
	pdbDownloadButton.backgroundColor = [UIColor clearColor];
	[pdbDownloadDisplayView addSubview:pdbDownloadButton];

//	pdbInformationWebView. = codeForCurrentlyDownloadingProtein;
}

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation
{
	// Return YES for supported orientations
	return (interfaceOrientation == UIInterfaceOrientationPortrait);
}

- (void)didReceiveMemoryWarning
{
}

#pragma mark -
#pragma mark View control methods

- (IBAction)showWebPageForMolecule;
{
	[UIView beginAnimations:nil context:NULL];
	[UIView setAnimationDuration:1];
	[UIView setAnimationTransition:UIViewAnimationTransitionCurlUp forView:self.view cache:YES];

	[pdbDownloadDisplayView removeFromSuperview];
	[self.view addSubview:pdbInformationWebView];
	pdbCodeSearchWebView.delegate = self;

	UIBarButtonItem *cancelButtonItem = [[UIBarButtonItem alloc] initWithTitle:NSLocalizedStringFromTable(@"Done", @"Localized", nil) style:UIBarButtonItemStylePlain target:self action:@selector(returnToDetailView)];
	self.navigationItem.rightBarButtonItem = cancelButtonItem;
	[cancelButtonItem release];

	[UIView commitAnimations];

	// Only send the user to the Protein Data Bank page if it hasn't already been loaded
	if ([pdbCodeSearchWebView request] == nil)
	{
		NSURLRequest *theRequest=[NSURLRequest requestWithURL:[NSURL URLWithString:[NSString stringWithFormat:@"http://www.rcsb.org/pdb/explore/explore.do?structureId=%@", codeForCurrentlyDownloadingProtein]]
												  cachePolicy:NSURLRequestUseProtocolCachePolicy
											  timeoutInterval:60.0];
		[pdbCodeSearchWebView loadRequest:theRequest];
	}
}

- (IBAction)returnToDetailView;
{
	[UIView beginAnimations:nil context:NULL];
	[UIView setAnimationDuration:1];
	[UIView setAnimationTransition:UIViewAnimationTransitionCurlDown forView:self.view cache:YES];

	self.navigationItem.rightBarButtonItem = nil;
	pdbCodeSearchWebView.delegate = nil;

	[pdbInformationWebView removeFromSuperview];
	[self.view addSubview:pdbDownloadDisplayView];

	[UIView commitAnimations];
}

- (IBAction)cancelDownload;
{
	downloadCancelled = YES;

	UIImage *newImage = [[UIImage imageNamed:@"greenButton.png"] stretchableImageWithLeftCapWidth:12.0 topCapHeight:0.0];
	[pdbDownloadButton setBackgroundImage:newImage forState:UIControlStateNormal];
	[pdbDownloadButton removeTarget:self action:@selector(cancelDownload) forControlEvents:UIControlEventTouchDown];
	[pdbDownloadButton addTarget:self action:@selector(downloadNewProtein) forControlEvents:UIControlEventTouchDown];
	[pdbDownloadButton setTitle:NSLocalizedStringFromTable(@"Download", @"Localized", nil) forState:UIControlStateNormal];

	//[self.delegate moleculeDownloadController:self didAddMolecule:nil withCode:nil];
}

#pragma mark -
#pragma mark Protein downloading

- (IBAction)downloadNewProtein;
{
	// Check if you already have a protein by that name
	// TODO: Put this check in the init method to grey out download button
	NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
	NSString *documentsDirectory = [paths objectAtIndex:0];

	if ([[NSFileManager defaultManager] fileExistsAtPath:[documentsDirectory stringByAppendingPathComponent:[NSString stringWithFormat:@"%@.pdb.gz", codeForCurrentlyDownloadingProtein]]])
	{
		UIAlertView *alert = [[UIAlertView alloc] initWithTitle:NSLocalizedStringFromTable(@"File already exists", @"Localized", nil) message:NSLocalizedStringFromTable(@"The molecule with this PDB code has already been downloaded", @"Localized", nil)
													   delegate:self cancelButtonTitle:NSLocalizedStringFromTable(@"OK", @"Localized", nil) otherButtonTitles: nil];
		alert.backgroundColor = [UIColor redColor];
		[alert show];
		[alert release];
		return;
	}

	if (![self downloadPDBFile])
	{
		UIAlertView *alert = [[UIAlertView alloc] initWithTitle:NSLocalizedStringFromTable(@"Connection failed", @"Localized", nil) message:NSLocalizedStringFromTable(@"Could not connect to the Protein Data Bank", @"Localized", nil)
													   delegate:self cancelButtonTitle:NSLocalizedStringFromTable(@"OK", @"Localized", nil) otherButtonTitles: nil];
		[alert show];
		[alert release];
		return;
	}
}

- (BOOL)downloadPDBFile;
{
	// Switch the mode of the download button to cancel
	UIImage *newImage = [[UIImage imageNamed:@"redButton.png"] stretchableImageWithLeftCapWidth:12.0 topCapHeight:0.0];
	[pdbDownloadButton setBackgroundImage:newImage forState:UIControlStateNormal];
	[pdbDownloadButton removeTarget:self action:@selector(downloadNewProtein) forControlEvents:UIControlEventTouchDown];
	[pdbDownloadButton addTarget:self action:@selector(cancelDownload) forControlEvents:UIControlEventTouchDown];
	[pdbDownloadButton setTitle:NSLocalizedStringFromTable(@"Cancel download", @"Localized", nil) forState:UIControlStateNormal];

	downloadStatusBar.progress = 0.0f;
	[self enableControls:NO];
	[indefiniteDownloadIndicator startAnimating];
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
	downloadStatusText.hidden = NO;
	downloadStatusText.text = NSLocalizedStringFromTable(@"Connecting...", @"Localized", nil);

//	NSString *locationOfRemotePDBFile = [NSString stringWithFormat:@"http://www.sunsetlakesoftware.com/sites/default/files/%@.pdb.gz", pdbCode];
	NSString *locationOfRemotePDBFile = [NSString stringWithFormat:@"http://www.rcsb.org/pdb/files/%@.pdb.gz", codeForCurrentlyDownloadingProtein];

	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
	NSURLRequest *theRequest=[NSURLRequest requestWithURL:[NSURL URLWithString:locationOfRemotePDBFile]
											  cachePolicy:NSURLRequestUseProtocolCachePolicy
										  timeoutInterval:60.0];
	downloadConnection = [[NSURLConnection alloc] initWithRequest:theRequest delegate:self];
	if (downloadConnection)
	{
		// Create the NSMutableData that will hold
		// the received data
		// receivedData is declared as a method instance elsewhere
		downloadedFileContents = [[NSMutableData data] retain];
	}
	else
	{
		// inform the user that the download could not be made
		return NO;
	}
	return YES;
}

- (void)enableControls:(BOOL)controlsAreEnabled;
{
	pdbInformationDisplayButton.enabled = controlsAreEnabled;
//	pdbDownloadButton.enabled = controlsAreEnabled;
}

- (void)downloadCompleted;
{
	[downloadConnection release];
	downloadConnection = nil;

	[downloadedFileContents release];
	downloadedFileContents = nil;
	downloadStatusBar.hidden = YES;
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
	[indefiniteDownloadIndicator stopAnimating];
	downloadStatusText.hidden = YES;

	[self enableControls:YES];
}

#pragma mark -
#pragma mark URL connection delegate methods

- (void)connection:(NSURLConnection *)connection didFailWithError:(NSError *)error;
{
	UIAlertView *alert = [[UIAlertView alloc] initWithTitle:NSLocalizedStringFromTable(@"Connection failed", @"Localized", nil) message:NSLocalizedStringFromTable(@"Could not connect to the Protein Data Bank", @"Localized", nil)
												   delegate:self cancelButtonTitle:NSLocalizedStringFromTable(@"OK", @"Localized", nil) otherButtonTitles: nil];
	[alert show];
	[alert release];

	[self downloadCompleted];
}

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data;
{
	// Concatenate the new data with the existing data to build up the downloaded file
	// Update the status of the download

	if (downloadCancelled)
	{
		[connection cancel];
		[self downloadCompleted];
		downloadCancelled = NO;
		return;
	}
	[downloadedFileContents appendData:data];
	downloadStatusBar.progress = (float)[downloadedFileContents length] / (float)downloadFileSize;
	downloadStatusText.text = NSLocalizedStringFromTable(@"Downloading", @"Localized", nil);
}

- (void)connection:(NSURLConnection *)connection didReceiveResponse:(NSURLResponse *)response;
{
	downloadFileSize = [response expectedContentLength];

	// Stop the spinning wheel and start the status bar for download
	if ([response textEncodingName] != nil)
	{
		UIAlertView *alert = [[UIAlertView alloc] initWithTitle:NSLocalizedStringFromTable(@"Could not find file", @"Localized", nil) message:[NSString stringWithFormat:NSLocalizedStringFromTable(@"No protein with the code %@ exists in the data bank", @"Localized", nil), codeForCurrentlyDownloadingProtein]
													   delegate:self cancelButtonTitle:NSLocalizedStringFromTable(@"OK", @"Localized", nil) otherButtonTitles: nil];
		[alert show];
		[alert release];
		[connection cancel];
		[self downloadCompleted];
		return;
	}

	if (downloadFileSize > 0)
	{
		downloadStatusBar.hidden = NO;
		[indefiniteDownloadIndicator stopAnimating];
		[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
	}
	downloadStatusText.text = NSLocalizedStringFromTable(@"Connected", @"Localized", nil);

	// TODO: Deal with a 404 error by checking filetype header
}

- (void)connectionDidFinishLoading:(NSURLConnection *)connection;
{
	downloadStatusText.text = NSLocalizedStringFromTable(@"Processing...", @"Localized", nil);

	// Close off the file and write it to disk
	[self.delegate moleculeDownloadController:self didAddMolecule:downloadedFileContents withFilename:[NSString stringWithFormat:@"%@.pdb.gz", codeForCurrentlyDownloadingProtein]];

	[self downloadCompleted];
}

#pragma mark -
#pragma mark Webview delegate methods

- (void)webViewDidStartLoad:(UIWebView *)webView
{
	webLoadingLabel.hidden = NO;
	[webLoadingIndicator startAnimating];
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
	//	progView.hidden = NO;
}

- (void)webViewDidFinishLoad:(UIWebView *)webView
{
	webLoadingLabel.hidden = YES;
	[webLoadingIndicator stopAnimating];
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
}

- (void)webView:(UIWebView *)webView didFailLoadWithError:(NSError *)error
{
	// TODO: Present error dialog to user explaining what's going on
	[webLoadingIndicator stopAnimating];
	[[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:NO];
}

#pragma mark -
#pragma mark UIViewController methods

- (void)viewWillDisappear:(BOOL)animated
{
	pdbCodeSearchWebView.delegate = nil;

	[super viewWillDisappear:animated];
}

#pragma mark -
#pragma mark Accessors

@synthesize delegate;
@synthesize pdbDownloadDisplayView, pdbInformationWebView;
@synthesize moleculeTitleText, downloadStatusText;
@synthesize pdbInformationDisplayButton, pdbDownloadButton;
@synthesize downloadStatusBar;
@synthesize indefiniteDownloadIndicator;
@synthesize pdbCodeSearchWebView;
@synthesize webLoadingLabel;
@synthesize webLoadingIndicator;

@end


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Pertusaria etrusca Erichsen

### Remarks
null


text:
module.exports = { getServer };

const configs = {
  local: {
    host: 'localhost',
    port: 4723
  },
  saucelabs: {
    host: 'ondemand.saucelabs.com',
    port: 80,
    auth: process.env.SAUCE_USERNAME + ":" + process.env.SAUCE_ACCESS_KEY
  },
  browserstack: {
    host: 'hub-cloud.browserstack.com',
    port: 80,
    auth: process.env.BROWSERSTACK_USERNAME + ":" + process.env.BROWSERSTACK_ACCESS_KEY
  }
}

function getServer(environment) {
  return configs[environment.toLowerCase()];
}


text:
@interface UIView (JGAFrameCalculations)
- (void)setHeight:(float)height;
- (void)setWidth:(float)width;
- (void)setOriginX:(float)x;
- (void)setOriginY:(float)y;
- (void)setCenterX:(float)x;
- (void)setCenterY:(float)y;

- (void)JGA_alignToRightOfView:(UIView *)view withPadding:(CGFloat)padding;
- (void)JGA_alignToBottomOfView:(UIView *)view withPadding:(CGFloat)padding;

@end


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using Model;
using BookShopBLL;

namespace UI.Admin
{
    public partial class UserInfoUpdate : System.Web.UI.Page
    {
        protected UserInfo ui { get; set; }
        protected void Page_Load(object sender, EventArgs e)
        {
            UserInfoBLL bll = new UserInfoBLL();
            if(IsPostBack)
            {
                UserInfo ui = new UserInfo();
                ui.UserId = int.Parse(Request["uid"]);
                ui.UserName = Request["username"];
                ui.Email = Request["email"];
                ui.Address = Request["address"];
                ui.MobilePhone = Request["mobilephone"];
                if(bll.UpdateUserInfoById(ui))
                {
                    Response.Redirect("UserManagerList.aspx");
                }
                else
                {
                    Response.Redirect("Error.html");
                }
            }
            else
            {
                int id = int.Parse(Request["id"]);
                ui = bll.GetUserInfoById(id);
            }
        }
    }
}


text:
Agregar Newsletter

				<button type="button" class="close" data-dismiss="modal" aria-label="Close">
					×
				</button>

				<form id="form_add_newsletter">

						Seleccionar Empresa
						<select class="form-control" id="empresa" name="company">
							<?php foreach ($customer as $cu) {
								echo '<option value="'.$cu['idCustomer'].'">'.$cu['nameCustomer'].'</option>'; }
							?>
						</select>

								Día
								<select id="day" class="form-control" name="day">
									<?php for( $i = 1 ; $i <= 31 ; $i++ ) {
										echo '<option value="' . $i . '" >' . $i . '</option>';
									} ?>
								</select>

								Mes
								<select id="month" class="form-control" name="month">
									<option value="1">Enero</option>
									<option value="2">Febrero</option>
									<option value="3">Marzo</option>
									<option value="4">Abril</option>
									<option value="5">Mayo</option>
									<option value="6">Junio</option>
									<option value="7">Julio</option>
									<option value="8">Agosto</option>
									<option value="9">Septiembre</option>
									<option value="10">Octubre</option>
									<option value="11">Nomviembre</option>
									<option value="12">Diciembre</option>
								</select>

								Año
								<select id="year" class="form-control" name="year">
									<option selected><?=date('Y');?></option>
								</select>

						Horario
						<select id="horary" class="form-control" name="horary">
							<option value="Matutino">Matutino</option>
							<option value="Vespertino">Vespertino</option>
						</select>

						LINK PRIMERAS PLANAS
						<input type="text" class="form-control" id="primeras_planas"  name="link1" placeholder="Link">

						PORTADAS NEGOCIOS
						<input type="text" class="form-control" id="portadas_negocios"  name="link2" placeholder="Link">

						CARTONES
						<input type="text" class="form-control" id="cartones"  name="link3" placeholder="Link">

						 COLUMNAS NEGOCIOS
						<input type="text" class="form-control" id="columnas_negocios"  name="link4" placeholder="Link">

						COLUMNAS POLÍTICAS
						<input type="text" class="form-control" id="columnas_politicas"  name="link5" placeholder="Link">

						PORTADA ESPECTACULOS
						<input type="text" class="form-control" id="candidatos_presidenciales"  name="link6" placeholder="Link">

				</form>

Newsletter Agregado Correctamente

					<button type="button" class="btn btn-primary" id="add_newsletter">Agregar</button>


text:
This repository will host the code for the future midi to laser cutter converter.

- General chatting can be done at [Gitter](https://gitter.im/Wintergatan/Midi-to-laser-cutter)
- Slow discussions can be started in the [Issue tracker](https://github.com/Wintergatan/Midi-to-laser-cutter/issues)
- See current version here: [Link](https://wintergatan.github.io/Midi-to-laser-cutter/)
- Prototype B here (Supports Chrome and Firefox): [Link](https://wintergatan.github.io/Midi-to-laser-cutter/experimental/musicboxeditor/dist/)
- [Info on how to contribute](https://github.com/Wintergatan/Midi-to-laser-cutter/blob/master/CONTRIBUTING.md)