小编Cam*_*rzt的帖子

我有一个actionmailer类和相关的开销,它完美地工作.但是,在我的单元测试(rails default minitest)中,电子邮件正文是空的.这是为什么？

我的邮件类:

class TermsMailer < ApplicationMailer
  default from: "info@domain.com"
  def notice_email(user,filename)
    @user = user
    @file = filename
    mail(to: "info@domain.com", subject: 'Data downloaded')
  end
end

我的测试:

require 'test_helper'

class TermsMailerTest < ActionMailer::TestCase
  test "notice" do
    email = TermsMailer.notice_email(users(:me),'file.ext').deliver_now
    assert_not ActionMailer::Base.deliveries.empty?
    assert_equal ['info@domain.com'], email.from
    assert_equal ['info@domain.com'], email.to
    assert_equal 'Data downloaded', email.subject
    assert_equal 'arbitrary garbage for comparison', email.body.to_s
  end
end

此邮件的视图不是空白,实际上内容通过电子邮件发送.那么为什么我的测试中的电子邮件正文空白？

我正在使用Mac OS X Mountain Lion中的一个应用程序,该应用程序需要访问Keychain Access中我的一些证书的私钥.由于此应用程序将在服务器上运行,因此我需要避免弹出对话框,该对话框要求用户允许应用程序访问私钥:

我知道通过单击"始终允许"对话框将不再弹出该私钥,问题是我将使用不同的密钥.

提前致谢,

Mikywan.

我有一个有效的功能,但比我想要的更专业,并且效率低下,我想解决这个问题.

工作但有缺陷的功能:

fn iter_to_min<T>(i:T) -> i64 where T:Iterator<Item=String>{
    i.collect::<Vec<String>>()
        .iter()
        .flat_map(|s|s.split_whitespace())
        .map(str::trim)
        .map(str::parse::<i64>)
        .map(Result::unwrap)
        .min()
        .expect("No min found.")
}

我不喜欢这种实现的原因是:

• i64是硬编码的,我想重用此函数u64以及可能的其他返回类型
• 它收集它的输入只是为了立即迭代它,效率很低(没有理由的堆分配)
• flat_map在所有情况下,传递给的闭包可能都不会被LLVM优化掉

最接近我的理想功能:

use std::str::FromStr;

fn iter_to_min<T,U>(i:T) -> U where T:Iterator<Item=String>,U: Ord+FromStr{
    i.flat_map(str::split_whitespace)
        .map(str::trim)
        .map(str::parse::<U>)
        .map(Result::unwrap)
        .min()
        .expect("No min found.")
}

我看到的问题是:

• 传递给的论点str::split_whitespace是a String并且不会强制转换为astr
• 传递给他们的论点str::split_whitespace不知道是否存在足够长的时间
• Result::unwrap不会抱怨core::fmt::Debug该类型没有实现该特征<U as core::str::FromStr>::Err

我认为,通过聪明的终身记谱法和特质要求,至少有两个可以修复,而且谁知道可能有三种方式去三.

使用一些建议修复的示例代码:

use std::io::BufRead;
use std::str::FromStr;
use std::fmt::Debug;

fn iter_to_min<T,U>(i:T) -> U where T:Iterator<Item=String>,U: Ord+FromStr, U::Err: Debug{ …

我有一个rake任务测试,我按照我在网上找到的唯一例子进行设置.

它看起来像这样:

require 'test_helper'
require 'minitest/mock'
require 'rake'

class TestScrapeWelcome < ActiveSupport::TestCase
  def setup
    Rake.application.init
    Rake.application.load_rakefile

    @task = Rake::Task['scrape:scrape']
    @task.reenable
  end

  def teardown
    Rake::Task.clear
  end

  test "scraping text and sending to elasticsearch" do
    mocked_client = Minitest::Mock.new
    get_fixtures.each_with_index do |arg,i|
      mocked_client.expect :index, :return_value, [index: "test", type: 'welcome', id: i, body: arg]
    end
    Elasticsearch::Model.stub :client, mocked_client do
      @task.invoke
    end
    assert mocked_client.verify
  end

  private

  def get_fixtures
    (0..11).map { |i|
      File.read("test/fixtures/scrape/index_#{i}.json")
    }
  end

end

但是一旦任务开始运行,它再次开始运行而没有我做任何事情(puts在@task.invoke显示之前和之后打印任务只运行一次).

我想重用我制作的迭代器,以避免付费从头开始重新创建它.但迭代器似乎clone无法collect移动迭代器,因此我无法重用它.

这或多或少相当于我正在尝试做的事情.

let my_iter = my_string.unwrap_or("A").chars().flat_map(|c|c.to_uppercase()).map(|c| Tag::from(c).unwrap() );
let my_struct = {
  one: my_iter.collect(),
  two: my_iter.map(|c|{(c,Vec::new())}).collect(),
  three: my_iter.filter_map(|c|if c.predicate(){Some(c)}else{None}).collect(),
  four: my_iter.map(|c|{(c,1.0/my_float)}).collect(),
  five: my_iter.map(|c|(c,arg_time.unwrap_or(time::now()))).collect(),
  //etc...
}

我正在将一些Python移植到Rust作为学习练习,需要从文件或标准输入中获取输入.我保留了一个结构中输入的句柄,所以我想我只是做了一个Box<io::Read>但是我遇到了一个需要寻求输入的情况,而seek不是Read特征的一部分.我知道你不能在管道中寻找,所以我要继续并且现在假设这个方法只在输入是一个文件时才被调用,但我的问题是我无法在Rust中检查它和downcast.

我知道我可以使用enum作为两种输入类型,但似乎应该有一种更优雅的方式来做到这一点.这就是我的问题,你是如何做到这一点而不是弄得一团糟？

是否可以将stdin或文件包装在同一种缓冲区中,以便我可以使用该类型而不用担心IO的类型？

我试过Random.stub :rand, 1 do ... end和Kernel.stub :rand, 1 do ... end和Class.stub :rand, 1 do ... end(因为当我跑self.class,我跑rand(2)我得到的Class).我也尝试过更换rand(2),Random.rand(2)但没有用.

那么我该怎么把兰德剔除？

我最初在ruby中写了这个,然后发现MRI根本不支持并行执行.所以我在生锈中重写了它,但我对各种碎片的所有权有困难.

extern crate rand;
extern crate csv;
extern crate num_cpus;

use std::fs::File;
use csv::Reader;
use rand::{thread_rng, sample};
use std::thread;
use std::str::from_utf8;
use std::io::{self, Write};
use csv::index::{Indexed, create_index};

fn met_n_in_common(n:usize,csv:&mut Reader<File>)->usize{
    csv.byte_records().map(|r| if(from_utf8(r.unwrap().get(n).unwrap()).unwrap() == "TRUE"){1}else{0}).fold(0usize, |sum, i| sum + i)
}

fn mets_in_common(csv:&mut Reader<File>,current_set_length:usize)->usize {
    (0..csv.headers().unwrap().len()).map(|i| if(i == 0){0}else{met_n_in_common(i,csv)} ).filter(|&e| e==current_set_length ).count()
}

fn main() {

    let csv_s = || csv::Reader::from_file("/Users/camdennarzt/Documents/All 7000 series-Table 1-1-1-3.csv").unwrap();
    let mut csv = csv_s();
    let mut index_data = io::Cursor::new(Vec::new());
    create_index(csv_s(), index_data.by_ref()).unwrap();
    let mut index = Indexed::open(csv_s(), …

我已经多次写过这个问题,并且终于意识到我最大的问题是我不知道我想如何表示这些数据,这使得很难推断其余的代码.

数据在Python中的表示方式:

class LSP():
    C_MASK_MAP={
        "A":"Ch A",
        "B":"Ch B",
        "C":"Ch C",
        "D":"Ch D",
        "T":"Tmpr",
        "Y":"Batt",
        "L":"Acc"
    }

    ADC_CHANS= (
        "Ch A",
        "Ch B",
        "Ch C",
        "Ch D",
        "Tmpr",
        "Batt"
    )

    ADC_MAJORS = (
        "Ch A",
        "Ch B",
        "Ch C",
    )

我想象中的Rust代码(我意识到名称需要更新,但为了清楚起见,这里是相同的):

enum C_MASK_MAP {
    Ch_A = 'A',
    Ch_B = 'B',
    Ch_C = 'C',
    Ch_D = 'D',
    Tmpr = 'T',
    Batt = 'Y',
    Acc  = 'L'
}
//...
let ADC_CHANS = [
    C_MASK_MAP::Ch_A,
    C_MASK_MAP::Ch_B,
    C_MASK_MAP::Ch_C,
    C_MASK_MAP::Ch_D,
    C_MASK_MAP::Tmpr,
    C_MASK_MAP::Batt
];

ADC_MAJORS = …

我有一个http请求,我需要检查身体.但是当我这样做时,请求失败了.我假设这与读者需要重置有关,但谷歌搜索go ioutil reset ReadCloser没有变成任何看起来很有希望的东西.

c是一个*middleware.Context, c.Req.Request是一个http.Request, c.Req.Request.Body是一个io.ReadCloser

contents, _ := ioutil.ReadAll(c.Req.Request.Body)
log.Info("Request: %s", string(contents))
proxy.ServeHTTP(c.RW(), c.Req.Request)

特别是我得到的错误是 http: proxy error: http: ContentLength=133 with Body length 0

我可以用以下两种方式编写,第二种方法的灵感来自于创建一个引用自我的方法的参考集合的惯用方法是什么？:

channels.iter().flat_map(|c|c.to_uppercase()).collect(),
channels.clone().into_iter().flat_map(char::to_uppercase).collect(),

第二行必须克隆集合,因为char::to_uppercase它不接受引用作为它的参数,并.iter()提供引用并.into_iter()移动集合.

有没有办法做到这一点,不需要克隆集合或创建一个闭包？我并不讨厌闭包,我保证,我知道它们只是在LLVM中转换成(通常是内联的)函数调用,但是我喜欢在第二行中引用函数的干净,并且更喜欢使用它如果可以在没有克隆的情况下完成.

我正在尝试将Python脚本转换为Rust作为学习体验,并使工具更快,并缩小代码/可执行文件的大小.

我目前正在尝试转换一个部分,该部分创建一个自我方法的引用列表.现在我已经知道没有办法为方法绑定self变量,必须使用闭包并关闭调用方法的对象.但是当你创建一个闭包时,它会被分配一个唯一的匿名类型,所以我不认为我可以创建一个Vec或一组闭包而不用装箱它们,这可能是要走的路,但是有一些开销可能没有必要.

我想知道的是,有没有一种更生锈的方法来实现这一点,而不是类型系统的类型系统,而不是Python通知设计的方法引用列表？

self.dataProcessors = []
if(self.dataMode) :
    self.dataProcessors.append(self._processData_)
if(self.csvOn):
    self.dataProcessors.append(self._processData_CSV_)

我认为如果我能算出生命周期符号，这可能会起作用，我错了吗？

pub fn from<T:Pattern>(from: T) -> Result<Tag, &'static str> {
    match from {
        'A'|"A" => Ok(Tag::ChA),
        'B'|"B" => Ok(Tag::ChB),
        'C'|"C" => Ok(Tag::ChC),
        'D'|"D" => Ok(Tag::ChD),
        'T'|"Tmpr" => Ok(Tag::Tmpr),
        'Y'|"Batt" => Ok(Tag::Batt),
        'L'|"Acc" => Ok(Tag::Acc),
        _ => Err("Error: unknown channel"),
    }
}