felipesere

use std::pin::Pin;

use pin_project_lite::pin_project;

use crate::stream::Stream;
use crate::task::{Context, Poll};
use crate::future::Future;

pin_project! {
    /// A stream that was created from a bunch of futures.

felipesere

#[derive(Debug, AsExpression)]
#[sql_type = "Text"]
#[derive(serde::Serialize, serde::Deserialize)]
pub enum RepoEvents {
    LatestCommitOnMaster(Commit),
}

impl ToSql<Text, Sqlite> for RepoEvents {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Sqlite>) -> serialize::Result {
        use RepoEvents::*;

felipesere

table! {
    repo_activity_log (id) {
        id -> Integer,
        repo_id -> Integer,
        event -> Text,
        created_at -> Timestamp,
    }
}

felipesere

pub struct StaticFilesV2 {
    pub root: String,
}

pub(crate) type BoxFuture<'a, T> = std::pin::Pin<Box<dyn Future<Output = T> + Send + 'a>>;

impl <STATE: Send + Sync + 'static> Endpoint<STATE> for StaticFilesV2 {
    type Fut = BoxFuture<'static, Response>;
    fn call(&self, req: Request<STATE>) -> Self::Fut {
        let protected_request = Arc::new(Mutex::new( (req, self.root.clone()) ));

felipesere

error[E0277]: `std::rc::Rc<(dyn for<'r> std::ops::Fn(&'r std::ffi::OsStr) -> std::result::Result<(), std::ffi::OsString> + 'static)>` cannot be sent between threads safely
   --> src/main.rs:115:1
    |
115 | #[runtime::main]
    | ^^^^^^^^^^^^^^^^ `std::rc::Rc<(dyn for<'r> std::ops::Fn(&'r std::ffi::OsStr) -> std::result::Result<(), std::ffi::OsString> + 'static)>` cannot be sent between threads safely
    |
   ::: /Users/felipesere/.cargo/registry/src/github.com-1ecc6299db9ec823/runtime-raw-0.3.0-alpha.5/src/lib.rs:60:29
    |
60  |     F: Future<Output = T> + Send + 'static,
    |                             ---- required by this bound in `runtime_raw::enter`

felipesere

Folder structure:

Root
|--A
|  |--a1.spec
|  |--a2.spec
|  |--a3.spec
|
|--B
|  |--b1.spec

felipesere

"Programmable" getter in Java 6.

The get(...) method takes a Question and evaluates it. Questions have a bunch of "modern" chainable methods like:

• refineWith(Question q) or then (Question q)
• or(Question) and orAsk(Question q) and orAsk(otherSubject, Question q) for a matching answer type
• orDefaultTo(answer) in case of exceptions or null

felipesere

#!/usr/bin/env ruby

require 'set'

message = ARGV[0] # the file that contains the message (change this!)
source = ARGV[1] # can be template, merge, squash, commit 
commit_id = ARGV[2]

if ["merge","squash"].include?(source)
  return 1 # do nothing

felipesere

#[derive(Queryable, Debug)]
pub struct DownloadAnswer {
    pub timestamp: NaiveDateTime,
    pub email: String,
    pub requester: String,
    pub answers: Vec<String>
}

impl FromSql<(diesel::types::Timestamp, diesel::types::Text, diesel::types::Text, diesel::types::Array<diesel::types::Text>), diesel::pg::Pg> for DownloadAnswer {
    fn from_sql(bytes: Option<&[u8]>) -> Result<Self, Box<Error + Send + Sync>> {

felipesere

    lazy_static! {
        pub static ref ROCKET: rocket::Rocket = {
            println!("Creating a rocket");

            super::build_rocket("postgres://advisor_test@localhost/advisor_test")
        };
    }

    #[test]
    fn through_the_rocket_infrastructure() {