diff --git a/.env.test b/.env.test index 2f053a6e..3398f16e 100644 --- a/.env.test +++ b/.env.test @@ -7,6 +7,9 @@ PRIMO_SCOPE=cdi PRIMO_TAB=all PRIMO_VID=01MIT_INST:MIT SYNDETICS_PRIMO_URL=https://syndetics.com/index.php?client=primo +TACOS_HOST=FAKE_TACOS_HOST +TACOS_URL=http://FAKE_TACOS_HOST/graphql +TACOS_SOURCE=FAKE_TACOS_SOURCE TIMDEX_GRAPHQL=https://FAKE_TIMDEX_HOST/graphql TIMDEX_HOST=FAKE_TIMDEX_HOST TIMDEX_INDEX=FAKE_TIMDEX_INDEX \ No newline at end of file diff --git a/README.md b/README.md index 0ac7c522..3af8e50f 100644 --- a/README.md +++ b/README.md @@ -128,6 +128,7 @@ mode (e.g., `GDT=false` will still enable GDT features). Note that this is curre may have unexpected consequences if applied to other TIMDEX UI apps. - `GLOBAL_ALERT`: The main functionality for this comes from our theme gem, but when set the value will be rendered as safe html above the main header of the site. +- `ORIGINS`: sets origins for CORS (currently used only for TACOS API calls). - `PLATFORM_NAME`: The value set is added to the header after the MIT Libraries logo. The logic and CSS for this comes from our theme gem. - `PRIMO_TIMEOUT`: The number of seconds before a Primo request times out (default 6). - `REQUESTS_PER_PERIOD` - number of requests that can be made for general throttles per `REQUEST_PERIOD` @@ -136,6 +137,10 @@ may have unexpected consequences if applied to other TIMDEX UI apps. - `REDIRECT_REQUEST_PERIOD`- time in minutes used along with `REDIRECT_REQUEST_PERIOD` - `SENTRY_DSN`: Client key for Sentry exception logging. - `SENTRY_ENV`: Sentry environment for the application. Defaults to 'unknown' if unset. +- `TACOS_SOURCE`: If set, this value is sent to TACOS (as the `sourceSystem` value) to distinguish which application +instance is sending what search traffic. Defaults to "unset" if not defined. +- `TACOS_URL`: The GraphQL endpoint for the [TACOS API](https://github.com/mitlibraries/tacos/). When set, the + application will log search terms to TACOS (and eventually return suggested resources that TACOS detects). - `TIMDEX_INDEX`: Name of the index, or alias, to provide to the GraphQL endpoint. Defaults to `nil` which will let TIMDEX determine the best index to use. Wildcard values can be set, for example `rdi*` would search any indexes that begin with `rdi` in the underlying OpenSearch instance behind TIMDEX. - `TIMDEX_SOURCES`: Comma-separated list of sources to display in the advanced-search source selection element. This overrides the default which is set in ApplicationHelper. @@ -143,6 +148,10 @@ may have unexpected consequences if applied to other TIMDEX UI apps. #### Test Environment-only Variables - `SPEC_REPORTER`: Optional variable. If set, enables spec reporter style output from tests rather than minimal output. +- `TACOS_HOST`: Test Env only. Used to ensure the VCR cassettes can properly scrub specific host data to make sure we +get the same cassettes regardless of which host was used to generate the cassettes. This should be set to the hostname +that matches `TACOS_URL`. Ex: If `TACOS_URL` is `http://localhost:3001/graphql` then `TACOS_HOST` should be +`localhost:3001`. - `TIMDEX_HOST`: Test Env only. Used to ensure the VCR cassettes can properly scrub specific host data to make sure we get the same cassettes regardless of which host was used to generate the cassettes. This should be set to the host name that matches `TIMDEX_GRAPHQL`. Ex: If `TIMDEX_GRAPHQL` is `https://www.example.com/graphql` then `TIMDEX_HOST` should be `www.example.com`. ### Generating VCR Cassettes diff --git a/app/controllers/tacos_controller.rb b/app/controllers/tacos_controller.rb new file mode 100644 index 00000000..715e2247 --- /dev/null +++ b/app/controllers/tacos_controller.rb @@ -0,0 +1,9 @@ +class TacosController < ApplicationController + layout false + + def analyze + return unless ApplicationHelper.tacos_enabled? + + Tacos.analyze(params[:q]) + end +end diff --git a/app/helpers/application_helper.rb b/app/helpers/application_helper.rb index 710d0aa5..04cb03c6 100644 --- a/app/helpers/application_helper.rb +++ b/app/helpers/application_helper.rb @@ -1,4 +1,9 @@ module ApplicationHelper + def tacos_enabled? + ENV.fetch('TACOS_URL', '').present? + end + module_function :tacos_enabled? + def timdex_sources ENV.fetch('TIMDEX_SOURCES', timdex_source_defaults).split(',') end diff --git a/app/models/tacos.rb b/app/models/tacos.rb new file mode 100644 index 00000000..f9e1bc33 --- /dev/null +++ b/app/models/tacos.rb @@ -0,0 +1,49 @@ +class Tacos + # The tacos_client argument here is unused in production - it is provided for + # our test suite so that we can mock various error conditions to ensure that + # error handling happens as we intend. + def self.analyze(term, tacos_client = nil) + tacos_http = setup(tacos_client) + query = '{ "query": "{ logSearchEvent(searchTerm: \"' + clean_term(term) + '\", sourceSystem: \"' + tacos_source + '\" ) { phrase source detectors { suggestedResources { title url } } } }" }' + begin + raw_response = tacos_http.timeout(http_timeout).post(tacos_url, body: query) + JSON.parse(raw_response.to_s) + rescue HTTP::Error + {"error" => "A connection error has occurred"} + rescue JSON::ParserError + {"error" => "A parsing error has occurred"} + end + end + + private + + def self.clean_term(term) + term.gsub('"', '\'') + end + + def self.http_timeout + ENV.fetch('TIMDEX_TIMEOUT', 6).to_f + end + + def self.origins + ENV.fetch('ORIGINS', nil) + end + + # We define the HTTP connection this way so that it can be overridden during + # testing, to make sure that the .analyze method can handle specific error + # conditions. + def self.setup(tacos_client) + tacos_client || HTTP.persistent(tacos_url) + .headers(accept: 'application/json', + 'Content-Type': 'application/json', + origin: origins) + end + + def self.tacos_source + ENV.fetch('TACOS_SOURCE', 'timdexui_unset') + end + + def self.tacos_url + ENV.fetch('TACOS_URL', nil) + end +end diff --git a/app/views/search/_trigger_tacos.html.erb b/app/views/search/_trigger_tacos.html.erb new file mode 100644 index 00000000..967e34fc --- /dev/null +++ b/app/views/search/_trigger_tacos.html.erb @@ -0,0 +1,8 @@ +<% return unless (tacos_enabled? and @enhanced_query[:q].present?) %> + +<% data_url = "/analyze?q=#{URI.encode_www_form_component(@enhanced_query[:q])}" %> + +
> +
diff --git a/app/views/search/results.html.erb b/app/views/search/results.html.erb index d9b97e02..aa89ac79 100644 --- a/app/views/search/results.html.erb +++ b/app/views/search/results.html.erb @@ -68,4 +68,6 @@ <% end %> +<%= render(partial: 'trigger_tacos') if tacos_enabled? %> + <%= javascript_include_tag "filters" %> diff --git a/app/views/tacos/analyze.html.erb b/app/views/tacos/analyze.html.erb new file mode 100644 index 00000000..ef05b8b3 --- /dev/null +++ b/app/views/tacos/analyze.html.erb @@ -0,0 +1 @@ + diff --git a/config/routes.rb b/config/routes.rb index ec77b2e3..ce24c7ef 100644 --- a/config/routes.rb +++ b/config/routes.rb @@ -8,6 +8,8 @@ get 'issn', to: 'fact#issn' get 'pmid', to: 'fact#pmid' + get 'analyze', to: 'tacos#analyze' + get 'record/(:id)', to: 'record#view', as: 'record', diff --git a/test/controllers/search_controller_test.rb b/test/controllers/search_controller_test.rb index b3be172c..c33385ed 100644 --- a/test/controllers/search_controller_test.rb +++ b/test/controllers/search_controller_test.rb @@ -275,7 +275,7 @@ def setup end assert_response :success - assert_select('div[data-content-loader-url-value]', 0) + assert_select('div[data-content-loader-url-value].fact-container', 0) end end @@ -305,7 +305,7 @@ def setup assert_response :success - assert_select('div[data-content-loader-url-value]', 0) + assert_select('div[data-content-loader-url-value].fact-container', 0) end end @@ -333,7 +333,7 @@ def setup end assert_response :success - assert_select('div[data-content-loader-url-value]', 0) + assert_select('div[data-content-loader-url-value].fact-container', 0) end end @@ -361,7 +361,31 @@ def setup end assert_response :success - assert_select('div[data-content-loader-url-value]', 0) + assert_select('div[data-content-loader-url-value].fact-container', 0) + end + end + + test 'TACOS intervention is inserted when TACOS enabled' do + VCR.use_cassette('tacos', + allow_playback_repeats: true) do + get '/results?q=tacos' + + assert_response :success + + tacos_div = assert_select('div[data-content-loader-url-value].tacos-container') + assert_equal '/analyze?q=tacos', tacos_div.attribute('data-content-loader-url-value').value + end + end + + test 'TACOS intervention not inserted when TACOS not enabled' do + VCR.use_cassette('tacos', + allow_playback_repeats: true) do + ClimateControl.modify(TACOS_URL: '') do + get '/results?q=tacos' + end + assert_response :success + + assert_select('div[data-content-loader-url-value].tacos-container', 0) end end diff --git a/test/controllers/tacos_controller_test.rb b/test/controllers/tacos_controller_test.rb new file mode 100644 index 00000000..9432182f --- /dev/null +++ b/test/controllers/tacos_controller_test.rb @@ -0,0 +1,12 @@ +require 'test_helper' + +class TacosControllerTest < ActionDispatch::IntegrationTest + test 'analyze route exists but returns an HTML comment for now' do + VCR.use_cassette('tacos direct') do + get '/analyze?q=direct' + + assert_response :success + assert_equal "\n", response.body + end + end +end diff --git a/test/helpers/application_helper_test.rb b/test/helpers/application_helper_test.rb index 01df7651..cf3fdbba 100644 --- a/test/helpers/application_helper_test.rb +++ b/test/helpers/application_helper_test.rb @@ -3,6 +3,16 @@ class ApplicationHelperTest < ActionView::TestCase include ApplicationHelper + test 'tacos_enabled? requires TACOS_URL env variable to have non-zero length' do + ClimateControl.modify TACOS_URL: 'foo' do + assert_equal true, tacos_enabled? + end + + ClimateControl.modify TACOS_URL: '' do + assert_equal false, tacos_enabled? + end + end + test 'index_page_title renders as expected' do assert_equal 'Search | MIT Libraries', index_page_title end diff --git a/test/models/tacos_test.rb b/test/models/tacos_test.rb new file mode 100644 index 00000000..8d545b5a --- /dev/null +++ b/test/models/tacos_test.rb @@ -0,0 +1,62 @@ +require 'test_helper' + +class TacosConnectionError + def timeout(_) + self + end + + def post(_url, body:) + raise HTTP::ConnectionError, "forced connection failure" + end +end + +class TacosParsingError + def timeout(_) + self + end + + def post(_url, body:) + 'This is not valid json' + end +end + +class TacosTest < ActiveSupport::TestCase + test 'TACOS model has a call method that reflects a search term back' do + VCR.use_cassette('tacos popcorn') do + searchterm = 'popcorn' + + result = Tacos.analyze(searchterm) + + assert_instance_of Hash, result + assert_equal searchterm, result['data']['logSearchEvent']['phrase'] + end + end + + test 'TACOS model will use ENV to populate the sourceSystem value' do + VCR.use_cassette('tacos fake system') do + ClimateControl.modify(TACOS_SOURCE: 'faked') do + result = Tacos.analyze('popcorn') + + assert_equal 'faked', result['data']['logSearchEvent']['source'] + end + end + end + + test 'TACOS model catches connection errors' do + tacos_client = TacosConnectionError.new + + result = Tacos.analyze('popcorn', tacos_client) + + assert_instance_of Hash, result + assert_equal 'A connection error has occurred', result['error'] + end + + test 'TACOS model catches parsing errors' do + tacos_client = TacosParsingError.new + + result = Tacos.analyze('popcorn', tacos_client) + + assert_instance_of Hash, result + assert_equal 'A parsing error has occurred', result['error'] + end +end diff --git a/test/test_helper.rb b/test/test_helper.rb index 60b82092..3f113331 100644 --- a/test/test_helper.rb +++ b/test/test_helper.rb @@ -18,7 +18,7 @@ end VCR.configure do |config| - config.ignore_localhost = true + config.ignore_localhost = false config.cassette_library_dir = 'test/vcr_cassettes' config.hook_into :webmock config.allow_http_connections_when_no_cassette = false @@ -26,6 +26,8 @@ config.filter_sensitive_data('http://FAKE_TIMDEX_HOST/graphql/') { ENV.fetch('TIMDEX_GRAPHQL').to_s } config.filter_sensitive_data('FAKE_TIMDEX_INDEX') { ENV.fetch('TIMDEX_INDEX').to_s } config.filter_sensitive_data('FAKE_PRIMO_API_KEY') { ENV.fetch('PRIMO_API_KEY').to_s } + config.filter_sensitive_data('FAKE_TACOS_HOST') { ENV.fetch('TACOS_HOST').to_s } + config.filter_sensitive_data('http://FAKE_TACOS_HOST/graphql/') { ENV.fetch('TACOS_URL').to_s } end module ActiveSupport diff --git a/test/vcr_cassettes/tacos.yml b/test/vcr_cassettes/tacos.yml new file mode 100644 index 00000000..58875a52 --- /dev/null +++ b/test/vcr_cassettes/tacos.yml @@ -0,0 +1,88 @@ +--- +http_interactions: +- request: + method: post + uri: https://FAKE_TIMDEX_HOST/graphql + body: + encoding: UTF-8 + string: '{"query":"query TimdexSearch__BaseQuery($q: String, $citation: String, + $contributors: String, $fundingInformation: String, $identifiers: String, + $locations: String, $subjects: String, $title: String, $index: String, $from: + String, $booleanType: String, $accessToFilesFilter: [String!], $contentTypeFilter: + [String!], $contributorsFilter: [String!], $formatFilter: [String!], $languagesFilter: + [String!], $literaryFormFilter: String, $placesFilter: [String!], $sourceFilter: + [String!], $subjectsFilter: [String!]) {\n search(searchterm: $q, citation: + $citation, contributors: $contributors, fundingInformation: $fundingInformation, + identifiers: $identifiers, locations: $locations, subjects: $subjects, title: + $title, index: $index, from: $from, booleanType: $booleanType, accessToFilesFilter: + $accessToFilesFilter, contentTypeFilter: $contentTypeFilter, contributorsFilter: + $contributorsFilter, formatFilter: $formatFilter, languagesFilter: $languagesFilter, + literaryFormFilter: $literaryFormFilter, placesFilter: $placesFilter, sourceFilter: + $sourceFilter, subjectsFilter: $subjectsFilter) {\n hits\n records {\n timdexRecordId\n title\n contentType\n contributors + {\n kind\n value\n }\n publicationInformation\n dates + {\n kind\n value\n }\n links {\n kind\n restrictions\n text\n url\n }\n notes + {\n kind\n value\n }\n highlight {\n matchedField\n matchedPhrases\n }\n provider\n rights + {\n kind\n description\n uri\n }\n sourceLink\n summary\n }\n aggregations + {\n accessToFiles {\n key\n docCount\n }\n contentType + {\n key\n docCount\n }\n contributors {\n key\n docCount\n }\n format + {\n key\n docCount\n }\n languages {\n key\n docCount\n }\n literaryForm + {\n key\n docCount\n }\n places {\n key\n docCount\n }\n source + {\n key\n docCount\n }\n subjects {\n key\n docCount\n }\n }\n }\n}","variables":{"from":"0","q":"tacos","booleanType":"AND","index":"FAKE_TIMDEX_INDEX"},"operationName":"TimdexSearch__BaseQuery"}' + headers: + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - application/json + User-Agent: + - MIT Libraries Client + Content-Type: + - application/json + response: + status: + code: 200 + message: OK + headers: + Cache-Control: + - max-age=0, private, must-revalidate + Content-Length: + - '39172' + Content-Type: + - application/json; charset=utf-8 + Etag: + - W/"46d0fef2dc0398207ff0f67ac58ceb8f" + Nel: + - '{"report_to":"heroku-nel","response_headers":["Via"],"max_age":3600,"success_fraction":0.01,"failure_fraction":0.1}' + Referrer-Policy: + - strict-origin-when-cross-origin + Report-To: + - '{"group":"heroku-nel","endpoints":[{"url":"https://nel.heroku.com/reports?s=9lAxEBscLCBgQX%2Bp%2FLIPNnsiIz971izVEylC%2FOD3ERE%3D\u0026sid=67ff5de4-ad2b-4112-9289-cf96be89efed\u0026ts=1759503031"}],"max_age":3600}' + Reporting-Endpoints: + - heroku-nel="https://nel.heroku.com/reports?s=9lAxEBscLCBgQX%2Bp%2FLIPNnsiIz971izVEylC%2FOD3ERE%3D&sid=67ff5de4-ad2b-4112-9289-cf96be89efed&ts=1759503031" + Server: + - Heroku + Strict-Transport-Security: + - max-age=63072000; includeSubDomains + Vary: + - Accept, Origin + Via: + - 1.1 heroku-router + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + X-Permitted-Cross-Domain-Policies: + - none + X-Request-Id: + - 356d6b91-414b-0ba9-98e4-597599888538 + X-Runtime: + - '0.487842' + X-Xss-Protection: + - '0' + Date: + - Fri, 03 Oct 2025 14:50:31 GMT + body: + encoding: ASCII-8BIT + string: !binary |- + {"data":{"search":{"hits":57,"records":[{"timdexRecordId":"alma:9935460484106761","title":"Broadway's hottest dish. Episode 2, Tacos \u0026 tostadas","contentType":["Projected medium"],"contributors":[{"kind":"director","value":"Devine, Kelly"},{"kind":"producer","value":"Devine, Kelly"},{"kind":"director","value":"Griffith, P. J"},{"kind":"producer","value":"Griffith, P. J"},{"kind":"publisher","value":"Broadway Licensing"}],"publicationInformation":["Broadway Licensing; 2020; New York, NY"],"dates":[{"kind":"Publication date","value":"2020"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53667165560006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["produced \u0026 directed by Kelly Devine \u0026 P.J. Griffith"]},{"kind":"General Note","value":["Title from resource description page (viewed April 03, 2023)"]},{"kind":"Participant or Performer Note","value":["Featuring: Sergio Trujillo, Jack Noseworthy, Katie Webber"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["\"TINA\"’s Katie Webber makes 'vegan' veggie \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e while discussing the benefits of dating a French rocker"]},{"matchedField":"citation","matchedPhrases":["Episode 2, \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e \u0026 tostadas. 2020. New York, NY : Broadway Licensing."]},{"matchedField":"title","matchedPhrases":["Episode 2, \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e \u0026 tostadas"]},{"matchedField":"subjects.value","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935460484106761","summary":["Believe it or not, Broadway’s hottest dancers can EAT. Now, it's time to get up close and personal by going inside their kitchens as they share their favorite recipes and viewers learn the answers to important questions, like: What’s the secret spice she can’t live without? Did he just he lick the spoon? How does she eat like the that and I still have an 8-pack? Tune in to find out! Tony Award-winning choreographer, Sergio Trujillo (\"AIN’T TOO PROUD: THE LIFE AND TIMES OF THE TEMPTATIONS\"), makes traditional Colombian 'Tostadas' and admits to being a tattletale growing up. \"TINA\"’s Katie Webber makes 'vegan' veggie tacos while discussing the benefits of dating a French rocker."]},{"timdexRecordId":"alma:9935965909606761","title":"Working posture assessment : the TACOs (time-based assessment computerized strategy) method","contentType":["Language material"],"contributors":[{"kind":"editor","value":"Colombini, Daniela"},{"kind":"editor","value":"Occhipinti, E. (Enrico)"}],"publicationInformation":["CRC Press; [2019]; Boca Raton, FL"],"dates":[{"kind":"Publication date","value":"2019"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":null,"url":"https://www.taylorfrancis.com/books/9781315149547"},{"kind":"Digital object URL","restrictions":null,"text":"Taylor \u0026 Francis Discovery Collection","url":"https://www.taylorfrancis.com/books/9781315149547"}],"notes":[{"kind":"Title Statement of Responsibility","value":["edited by Daniela Colombini and Enrico Occhipinti"]},{"kind":"General Note","value":["\"A CRC title.\""]},{"kind":"Bibliography Note","value":["Includes bibliographical references and index"]},{"kind":"Source of Description Note","value":["Print version record"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["implement the strategy for calculating risk associated with exposure to awkward postures, i.e. the \u003cspan class=\"highlight\"\u003eTACOS\u003c/span\u003e"]},{"matchedField":"contents","matchedPhrases":["The \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e method","Simple tools for using the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e method to assess postures : an example of a multitask job with in a","Simple tools for using the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e method to assess postures : the example of a multitask job based on","Simple tools for using the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e method to assess postures : the example of a multitask job based in"]},{"matchedField":"citation","matchedPhrases":["Working posture assessment : the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e (time-based assessment computerized strategy) method. 2019."]},{"matchedField":"title","matchedPhrases":["Working posture assessment : the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e (time-based assessment computerized strategy) method"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935965909606761","summary":["\"This book covers how to analyze awkward working postures of the spine and lower limbs in specific groups exposed. The methods covered suggests how to evaluate the postures correctly in very complex scenarios where workers are involved with multiple tasks and work cycles varying from day to day. Excel spreadsheets located on the authors website have been developed to gather, condense, and automatically process the data. The tools serve to implement the strategy for calculating risk associated with exposure to awkward postures, i.e. the TACOS method. Included are 5 case studies which include physiotherapists, workers from construction, archaeological digs, vineyards, and kindergarten teachers\"--"]},{"timdexRecordId":"alma:9935764833206761","title":"Working Posture Assessment : The TACOS (Time-Based Assessment Computerized Strategy) Method","contentType":["Language material"],"contributors":[{"kind":"editor","value":"Colombini, Daniela"},{"kind":"editor","value":"Occhipinti, Enrico"}],"publicationInformation":["CRC Press; [2018]; Boca Raton, FL","©2019"],"dates":[{"kind":"Publication date","value":"2018"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Taylor \u0026 Francis Evidence Based Ebook Collection","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53703652830006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["edited by Daniela Colombini and Enrico Occhipinti"]},{"kind":"Bibliography Note","value":["Includes bibliographical references and index"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["implement the strategy for calculating risk associated with exposure to awkward postures, i.e. the \u003cspan class=\"highlight\"\u003eTACOS\u003c/span\u003e"]},{"matchedField":"contents","matchedPhrases":["The \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e Method: Methods, Criteria, and Applications of Single-Task Jobs.","Simple Tools for Using the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e Method to Assess Postures: An Example of a Multitask Job in a Daily","Simple Tools for Using the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e Method to Assess Postures: An Example of a Multitask Job in a Weekly","Simple Tools for Using the \u003cspan class=\"highlight\"\u003eTACOs\u003c/span\u003e Method to Assess Postures: An Example of a Multitask Job in an Annual"]},{"matchedField":"citation","matchedPhrases":["Working Posture Assessment : The \u003cspan class=\"highlight\"\u003eTACOS\u003c/span\u003e (Time-Based Assessment Computerized Strategy) Method. 2018."]},{"matchedField":"title","matchedPhrases":["Working Posture Assessment : The \u003cspan class=\"highlight\"\u003eTACOS\u003c/span\u003e (Time-Based Assessment Computerized Strategy) Method"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935764833206761","summary":["This book covers how to analyze awkward working postures, particularly of the spine and lower limbs, in specific groups exposed. The methods covered suggests how to evaluate the postures correctly, taking account of the duration and sequence of the tasks involved, even in very complex scenarios where workers are involved with multiple tasks and work cycles varying from day to day. Excel spreadsheets located on the authors’ website (www.epmresearch.org) have been developed to gather, condense, and automatically process the data. The tools serve to implement the strategy for calculating risk associated with exposure to awkward postures, i.e. the TACOS method. Included are 5 case studies which include physiotherapists, workers from construction, archaeological digs, vineyards, and kindergarten teachers."]},{"timdexRecordId":"alma:990032705800106761","title":"Planet taco : a global history of Mexican food","contentType":["Language material"],"contributors":[{"kind":"Not specified","value":"Pilcher, Jeffrey M"}],"publicationInformation":["Oxford University Press; [2012]; Oxford ;","©2012"],"dates":[{"kind":"Publication date","value":"2012"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"EBSCOhost Ebooks","url":"http://search.ebscohost.com/login.aspx?direct=true\u0026scope=site\u0026db=nlebk\u0026db=nlabk\u0026AN=642150"}],"notes":[{"kind":"Title Statement of Responsibility","value":["Jeffrey M. Pilcher"]},{"kind":"Bibliography Note","value":["Includes bibliographical references (pages 268-282) and index"]},{"kind":"Source of Description Note","value":["Print version record"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["As late as the 1960s, \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e were virtually unknown outside Mexico and the American Southwest."]},{"matchedField":"contents","matchedPhrases":["Introduction: A tale of two \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e","Proto-\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e. Maize and the making of Mexico ; Burritos in the borderlands","National \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e.","Global \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e. The first wave of global Mexican ; The blue corn bonanza"]},{"matchedField":"subjects.value","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e - History","\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma990032705800106761","summary":["As late as the 1960s, tacos were virtually unknown outside Mexico and the American Southwest. Within fifty years the United States had shipped taco shells everywhere from Alaska to Australia, Morocco to Mongolia. But how did this tasty hand-held food, and Mexican food more broadly, become so ubiquitous? In this book the author traces the historical origins and evolution of Mexico's national cuisine, explores its incarnation as a Mexican American fast-food, shows how surfers became global pioneers of Mexican food, and how Corona beer conquered the world. The author is particularly enlightening on what the history of Mexican food reveals about the uneasy relationship between globalization and authenticity. The burritos and taco shells that many people think of as Mexican were actually created in the United States. But he argues that the contemporary struggle between globalization and national sovereignty to determine the authenticity of Mexican food goes back hundreds of years. During the nineteenth century, Mexicans searching for a national cuisine were torn between nostalgic \"Creole\" Hispanic dishes of the past and French haute cuisine, the global food of the day. Indigenous foods were scorned as unfit for civilized tables. Only when Mexican American dishes were appropriated by the fast food industry and carried around the world did Mexican elites rediscover the foods of the ancient Maya and Aztecs and embrace the indigenous roots of their national cuisine. From a taco cart in Hermosillo, Mexico to the \"Chili Queens\" of San Antonio and tamale vendors in Los Angeles., the author follows this highly adaptable cuisine, paying special attention to the people too often overlooked in the battle to define authentic Mexican food: Indigenous Mexicans and Mexican Americans"]},{"timdexRecordId":"alma:990020979270106761","title":"Planet taco : a global history of Mexican food","contentType":["Language material"],"contributors":[{"kind":"Not specified","value":"Pilcher, Jeffrey M"}],"publicationInformation":["Oxford University Press; c2012; New York"],"dates":[{"kind":"Publication date","value":"2012"}],"links":null,"notes":[{"kind":"Title Statement of Responsibility","value":["Jeffrey M. Pilcher"]},{"kind":"Bibliography Note","value":["Includes bibliographical references (p. 268-282) and index"]}],"highlight":[{"matchedField":"contents","matchedPhrases":["Introduction: A Tale of Two \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e","Proto-\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e","National \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e","Global \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]},{"matchedField":"subjects.value","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e - History","\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma990020979270106761","summary":null},{"timdexRecordId":"alma:9935127026606761","title":"Simply Ming. Season 15, episode 7, Rick Bayless","contentType":["Projected medium"],"contributors":[{"kind":"host","value":"Tsai, Ming"},{"kind":"director","value":"Donnelly, Laurie"},{"kind":"producer","value":"Donnelly, Laurie"},{"kind":"speaker","value":"Bayless, Rick"},{"kind":"production company","value":"WGBH Educational Foundation"}],"publicationInformation":["Public Broadcasting Service; 2017; Arlington, VA"],"dates":[{"kind":"Publication date","value":"2017"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53558273050006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["executive producer \u0026 director, Laurie Donnelly ; WGBH Educational Foundation"]},{"kind":"General Note","value":["Title from resource description page (viewed September 05, 2019)"]},{"kind":"Participant or Performer Note","value":["Ming Tsai, host ; Rick Bayless, guest"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["PBS's own chef Rick Bayless shares his Mexican flavors with some Mexican Street Corn \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e with Homemade"]},{"matchedField":"subjects.value","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935127026606761","summary":["PBS's own chef Rick Bayless shares his Mexican flavors with some Mexican Street Corn Tacos with Homemade Corn Tortillas, while Ming makes his new Egg Omelet Wrap with a Corn, Tomato, Watercress, and Fermented Black Bean Salsa."]},{"timdexRecordId":"alma:9935427532606761","title":"Try Thai tonight. Season 1, episode 4, Beef Laab","contentType":["Projected medium"],"contributors":[{"kind":"on-screen presenter","value":"Guntong, Nuchjana Jean"},{"kind":"director","value":"Rainey, Dean"},{"kind":"on-screen presenter","value":"Rainey, Dean"},{"kind":"production company","value":"Rainey Media"},{"kind":"publisher","value":"Rainey Media"}],"publicationInformation":["Rainey Media; 2018; [Place of publication not identified]"],"dates":[{"kind":"Publication date","value":"2018"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53655694630006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["[hosts, Nuchjana \"Jean\" Guntong, Dean Rainey] ; [director, Dean Rainey]"]},{"kind":"General Note","value":["Title from resource description page (viewed January 17, 2023)"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["Jean \u0026 Dean prepare Thai \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e - er, we mean minced Beef Laab served in lettuce leaf."]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935427532606761","summary":["Jean \u0026 Dean prepare Thai Tacos - er, we mean minced Beef Laab served in lettuce leaf."]},{"timdexRecordId":"alma:9935423710306761","title":"Mamacita : recipes celebrating life as a Mexican immigrant in America","contentType":["Language material"],"contributors":[{"kind":"author","value":"Pons, Andrea"}],"publicationInformation":["Princeton Architectural Press; [2022]; New York","©2022"],"dates":[{"kind":"Publication date","value":"2022"}],"links":null,"notes":[{"kind":"Title Statement of Responsibility","value":["Andrea Pons ; foreword by Hetty Lui McKinnon"]},{"kind":"Bibliography Note","value":["Includes bibliographical references and index"]}],"highlight":[{"matchedField":"contents","matchedPhrases":["Where are the \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e?"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935423710306761","summary":["\"A love letter to author Andrea Pons's native Mexico, weaving stories of her family's immigration to the United States with 75 delicious recipes from three generations of women in her family\"--"]},{"timdexRecordId":"alma:9935541547306761","title":"Indigenous stories. Season 4, episode 2, Indigenous cuisine in Toronto","contentType":["Projected medium"],"contributors":[{"kind":"director","value":"Yanchyk, Brandy"},{"kind":"host","value":"Yanchyk, Brandy"},{"kind":"producer","value":"Yanchyk, Brandy"},{"kind":"screenwriter","value":"Yanchyk, Brandy"},{"kind":"production company","value":"Brandy Y Productions"}],"publicationInformation":["Brandy Y Productions; 2023; Edmonton, AB"],"dates":[{"kind":"Publication date","value":"2023"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53686537780006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["director/producer/writer, Brandy Yanchyk"]},{"kind":"General Note","value":["Title from resource description page (viewed October 30, 2023)"]},{"kind":"Participant or Performer Note","value":["Host: Brandy Yanchyk"]},{"kind":"Source of Description Note","value":["Title from resource description page (viewed November 09, 2023)"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["Canadian journalist Brandy Yanchyk tastes Indigenous cuisine while making Indian \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e with Chef Shawn"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935541547306761","summary":["Canadian journalist Brandy Yanchyk tastes Indigenous cuisine while making Indian Tacos with Chef Shawn Adler at the Pow Wow Café."]},{"timdexRecordId":"alma:990023052790106761","title":"Serve yourself : nightly adventures in cooking for one","contentType":["Language material"],"contributors":[{"kind":"Not specified","value":"Yonan, Joe"}],"publicationInformation":["Ten Speed Press; c2011; Berkeley [Calif.]"],"dates":[{"kind":"Publication date","value":"2011"}],"links":null,"notes":[{"kind":"Title Statement of Responsibility","value":["Joe Yonan ; photographs by Ed Anderson"]},{"kind":"General Note","value":["\"With over 100 recipes for both weeknight staples and weekend projects\"--Cover"]},{"kind":"General Note","value":["Includes index"]}],"highlight":[{"matchedField":"contents","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma990023052790106761","summary":["A collection of one hundred recipes for dishes that serve one individual, with step-by-step instructions and photographs."]},{"timdexRecordId":"alma:990028556820106761","title":"Cool beans : the ultimate guide to cooking with the world's most versatile plant-based protein, with 125 recipes","contentType":["Language material"],"contributors":[{"kind":"author","value":"Yonan, Joe"},{"kind":"photographer","value":"Pick, Aubrie"}],"publicationInformation":["Ten Speed Press; [2020]; California ;"],"dates":[{"kind":"Publication date","value":"2020"}],"links":null,"notes":[{"kind":"Title Statement of Responsibility","value":["Joe Yonan ; photographs by Aubrie Pick"]},{"kind":"Bibliography Note","value":["Includes bibliographical references and index"]}],"highlight":[{"matchedField":"contents","matchedPhrases":["Burgers, sandwiches, wraps, \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e \u0026 a pizza"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma990028556820106761","summary":["\"A modern and fresh look at the diverse world of beans and pulses, including 125 recipes for globally inspired vegetarian mains, snacks, soups, and even desserts\"--"]},{"timdexRecordId":"alma:9935446041406761","title":"Treasures of the Mexican table : classic recipes, local secrets","contentType":["Language material"],"contributors":[{"kind":"author","value":"Jinich, Pati"},{"kind":"photographer","value":"Mosier, Angie"}],"publicationInformation":["Houghton Mifflin Harcourt; 2021; Boston","©2021"],"dates":[{"kind":"Publication date","value":"2021"}],"links":null,"notes":[{"kind":"Title Statement of Responsibility","value":["Pati Jinich ; photographs by Angie Mosier"]},{"kind":"General Note","value":["Map on liner papers"]},{"kind":"Bibliography Note","value":["Includes index"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["From Baja lobster \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e to Oaxacan-style grilled flank steak, these recipes represent the culinary diversity"]},{"matchedField":"contents","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e, quesadillas, burritos, and tamales"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935446041406761","summary":["\"The 'buoyant and brainy Mexican cooking authority' (New York Times) and star of the three-time James Beard Award-winning PBS series Pati's Mexican Table brings together more than 150 iconic dishes that define the country's cuisine. Although many of us can rattle off our favorite authentic Mexican dishes, we might be hard pressed to name more than ten. Which is preposterous, given that Mexico has a rich culinary history stretching back thousands of years. For her newest book, Pati Jinich brings home the signature recipes that home cooks, market vendors, and chefs have shared with her as she crisscrossed her native country for the past decade. From Baja lobster tacos to Oaxacan-style grilled flank steak, these recipes represent the culinary diversity of the nation that has, depending on how you count them, as many as thirty-two different cuisines. Each recipe is a classic. Each one comes with a story told in Pati's warm, relatable style. And each has been tested in Pati's American kitchen to ensure it is the best of its kind\"--"]},{"timdexRecordId":"alma:9935055463706761","title":"More food styling for photographers and stylists : a guide to creating your own appetizing art","contentType":["Language material"],"contributors":[{"kind":"Not specified","value":"Bellingham, Linda"},{"kind":"Not specified","value":"Bybee, Jean Ann"},{"kind":"Not specified","value":"Rogers, Brad G"}],"publicationInformation":["Focal Press; 2012; Waltham, Mass."],"dates":[{"kind":"Publication date","value":"2012"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"O'Reilly Online Learning: Academic/Public Library Edition","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53542882260006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["Linda Bellingham, Jean Ann Bybee, Brad G. Rogers"]},{"kind":"General Note","value":["Includes index"]}],"highlight":[{"matchedField":"contents","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935055463706761","summary":["Thanks to the exploding popularity of food-based television shows (entire networks, even), websites, books, and magazines, food stylists and food photographers are in more demand today than ever before. While there are many amazing opportunities for creative professionals to showcase their work in ads, cookbooks, blogs, and food packaging, there is also more competition for these jobs. Whether you are a food stylist who works alongside photographers or a food photographer yourself, you'll find everything you need to know to give your portfolio that little extra push in this expert guide by "]},{"timdexRecordId":"alma:9935127028206761","title":"Simply Ming. Season 15, episode 3, Aarón Sanchez","contentType":["Projected medium"],"contributors":[{"kind":"host","value":"Tsai, Ming"},{"kind":"director","value":"Donnelly, Laurie"},{"kind":"producer","value":"Donnelly, Laurie"},{"kind":"speaker","value":"Sánchez, Aarón"},{"kind":"production company","value":"WGBH Educational Foundation"}],"publicationInformation":["Public Broadcasting Service; 2017; Arlington, VA"],"dates":[{"kind":"Publication date","value":"2017"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53558273010006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["executive producer \u0026 director, Laurie Donnelly ; WGBH Educational Foundation"]},{"kind":"General Note","value":["Title from resource description page (viewed September 05, 2019)"]},{"kind":"Participant or Performer Note","value":["Ming Tsai, host ; Aarón Sánchez, guest"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["Aarón Sánchez -- judge on Chopped and Masterchef -- visits Ming in his loft to cook his Albóndigas \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935127028206761","summary":["One of the world's most distinguished Latin chefs, Aarón Sánchez -- judge on Chopped and Masterchef -- visits Ming in his loft to cook his Albóndigas Tacos, while Ming makes Beef and Salted Watercress Scallion Pancakes."]},{"timdexRecordId":"alma:9935762113306761","title":"Decentering subjectivity in everyday eating and drinking : digesting reality","contentType":["Language material"],"contributors":[{"kind":"author","value":"Lara, Ali"}],"publicationInformation":["Routledge; 2021; Oxford, England ;"],"dates":[{"kind":"Publication date","value":"2021"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Taylor \u0026 Francis Evidence Based Ebook Collection","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53702807500006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["Ali Lara"]},{"kind":"Bibliography Note","value":["Includes bibliographical references and index"]},{"kind":"Source of Description Note","value":["Description based on print version record"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["The author uses examples from daily life related to eating and drinking habits like, 'eating \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e' or"]},{"matchedField":"contents","matchedPhrases":["1 \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e and heat"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935762113306761","summary":["This book analyzes the configurations of reality as manifested in everyday practices of eating and drinking. The author uses examples from daily life related to eating and drinking habits like, 'eating tacos' or 'taking a shot of mezcal' to offer an interface of interaction between body and mind connecting all scales of reality."]},{"timdexRecordId":"alma:9935961269206761","title":"Decentering subjectivity in everyday eating and drinking : digesting reality","contentType":["Language material"],"contributors":[{"kind":"author","value":"Lara, Ali"}],"publicationInformation":["Routledge; 2021; Abingdon, Oxon ;"],"dates":[{"kind":"Publication date","value":"2021"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":null,"url":"https://www.taylorfrancis.com/books/9781003082194"},{"kind":"Digital object URL","restrictions":null,"text":"Taylor \u0026 Francis Discovery Collection","url":"https://www.taylorfrancis.com/books/9781003082194"}],"notes":[{"kind":"Title Statement of Responsibility","value":["Ali Lara"]},{"kind":"Bibliography Note","value":["Includes bibliographical references and index"]},{"kind":"Source of Description Note","value":["Online resource; title from digital title page (viewed on December 30, 2020)"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["The author uses concrete examples from daily life related to eating and drinking habitssuch as\"eating \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e"]},{"matchedField":"contents","matchedPhrases":["1 \u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e and heat"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935961269206761","summary":["This important book offers a model to analyze the configurations of reality as manifested in everyday practices of eating and drinking in relation to the development of human subjectivity. The author uses concrete examples from daily life related to eating and drinking habitssuch as\"eating tacos\" or \"taking a shot of mezcal\", to offer an interface of interaction between body/mind and material entities connecting all scales of reality. Borrowing scientific insights from molecular biology and neuroscience, combined with a touch of decolonial spirit, the author examines specific 'processes' and/or 'objects' triggered by eating and drinking events, such as the production of heat as you eat a taco, or the interchange of knowledge while drinking mezcal. The book develops an approach to human subjectivity informed by material and aesthetic encounters beyond the analysis of language, representation, and social structures and aims to contribute to the contemporary landscape of efforts decentering our understanding of both human and non-human affairs. With its multidimensional exploration of our relationship with food, this is thought-provoking reading for scholars and students in critical psychology, philosophy, and the social sciences"]},{"timdexRecordId":"alma:990013486990106761","title":"Mariachi music in America : experiencing music, expressing culture","contentType":["Language material"],"contributors":[{"kind":"Not specified","value":"Sheehy, Daniel"}],"publicationInformation":["Oxford University Press; 2006; New York"],"dates":[{"kind":"Publication date","value":"2006"}],"links":null,"notes":[{"kind":"Title Statement of Responsibility","value":["Daniel Sheehy"]},{"kind":"Bibliography Note","value":["Includes bibliographical references (p. 100-106) and index"]}],"highlight":[{"matchedField":"contents","matchedPhrases":[": \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e with ketchup or salsa? : the challenge of change"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma990013486990106761","summary":null},{"timdexRecordId":"alma:9935074078506761","title":"That's the truth","contentType":["Musical sound recording"],"contributors":[{"kind":"performer","value":"Boals, Richard"}],"publicationInformation":["JSP Records; 2005; [Place of publication not identified]"],"dates":[{"kind":"Publication date","value":"2005"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Music Online: American Music - United States","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53546894780006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["Richard Boals"]},{"kind":"General Note","value":["Title from cover image (viewed November 9, 2021)"]},{"kind":"General Note","value":["Streaming audio files"]},{"kind":"Participant or Performer Note","value":["Richard Boals, lead guitar, vocals"]}],"highlight":[{"matchedField":"contents","matchedPhrases":["\u003cspan class=\"highlight\"\u003eTacos\u003c/span\u003e for two"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935074078506761","summary":null},{"timdexRecordId":"alma:9935081736306761","title":"Culinary journeys. Season 2, episode 9, Enrique Olvera : Mexico","contentType":["Projected medium"],"contributors":[{"kind":"speaker","value":"Olvera, Enrique"},{"kind":"production company","value":"Cable News Network"}],"publicationInformation":["CNN Newsource Sales; 2016; Atlanta, GA"],"dates":[{"kind":"Publication date","value":"2016"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53548515810006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["Cable News Network"]},{"kind":"General Note","value":["Title from resource description page (viewed March 06, 2019)"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["conquistadores of Spain which have fused together and are found today in streets filled with tortas, \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935081736306761","summary":["The history of Mexico is one that is told through its cuisine - bold flavours from the Aztecs of Mesoamerica and the conquistadores of Spain which have fused together and are found today in streets filled with tortas, tacos and tamales."]},{"timdexRecordId":"alma:9935515057106761","title":"The great American recipe. Season 2, episode 7","contentType":["Projected medium"],"contributors":[{"kind":"host","value":"Derry, Tiffany"},{"kind":"host","value":"Ramos, Alejandra (Chef)"},{"kind":"host","value":"Cohen, Leah (Chef)"},{"kind":"host","value":"Elliot, Graham"},{"kind":"production company","value":"VPM Media Corporation"},{"kind":"film distributor","value":"Public Broadcasting Service (U.S.)"},{"kind":"publisher","value":"Public Broadcasting Service (U.S.)"}],"publicationInformation":["Public Broadcasting Service; 2023; Arlington, VA"],"dates":[{"kind":"Publication date","value":"2023"}],"links":[{"kind":"Digital object URL","restrictions":null,"text":"Academic Video Online (AVON)","url":"https://na06.alma.exlibrisgroup.com/view/uresolver/01MIT_INST/openurl?u.ignore_date_coverage=true\u0026portfolio_pid=53680465530006761\u0026Force_direct=true"}],"notes":[{"kind":"Title Statement of Responsibility","value":["produced by VPM Media Corporation in association with PBS"]},{"kind":"General Note","value":["Title from resource description page (viewed August 18, 2023)"]},{"kind":"Participant or Performer Note","value":["Hosts: Alejandra Ramos, Tiffany Derry, Leah Cohen, Graham Elliott"]}],"highlight":[{"matchedField":"summary","matchedPhrases":["From carne asada \u003cspan class=\"highlight\"\u003etacos\u003c/span\u003e to corn chaat to chicken chapli, the cooks prepare dishes inspired by a close"]}],"provider":null,"rights":null,"sourceLink":"https://mit.primo.exlibrisgroup.com/discovery/fulldisplay?vid=01MIT_INST:MIT\u0026docid=alma9935515057106761","summary":["See how the home cooks put it all on the plate in their last chance to impress before the finale. From carne asada tacos to corn chaat to chicken chapli, the cooks prepare dishes inspired by a close friend and recipes that changed their lives."]}],"aggregations":{"accessToFiles":[],"contentType":[{"key":"language material","docCount":46},{"key":"projected medium","docCount":9},{"key":"musical sound recording","docCount":2}],"contributors":[{"key":"donnelly, laurie","docCount":4},{"key":"yanchyk, brandy","docCount":4},{"key":"pilcher, jeffrey m","docCount":3},{"key":"public broadcasting service (u.s.)","docCount":3},{"key":"ramos, alejandra (chef)","docCount":3},{"key":"cohen, leah (chef)","docCount":2},{"key":"colombini, daniela","docCount":2},{"key":"derry, tiffany","docCount":2},{"key":"devine, kelly","docCount":2},{"key":"domènech, conxita","docCount":2}],"format":[],"languages":[{"key":"english","docCount":53},{"key":"in english","docCount":9},{"key":"spanish","docCount":3},{"key":"no linguistic content","docCount":1},{"key":"original language in english","docCount":1},{"key":"portuguese","docCount":1}],"literaryForm":[{"key":"nonfiction","docCount":45},{"key":"fiction","docCount":1}],"places":[],"source":[{"key":"mit alma","docCount":57}],"subjects":[{"key":"cooking, mexican","docCount":8},{"key":"cooking","docCount":7},{"key":"food habits","docCount":5},{"key":"history","docCount":5},{"key":"tacos","docCount":5},{"key":"artificial intelligence","docCount":4},{"key":"cooking, american","docCount":4},{"key":"cooking, mexican - history","docCount":3},{"key":"mexican americans","docCount":3},{"key":"mexico","docCount":3}]}}}} + recorded_at: Fri, 03 Oct 2025 14:50:31 GMT +recorded_with: VCR 6.3.1 diff --git a/test/vcr_cassettes/tacos_direct.yml b/test/vcr_cassettes/tacos_direct.yml new file mode 100644 index 00000000..d2a93580 --- /dev/null +++ b/test/vcr_cassettes/tacos_direct.yml @@ -0,0 +1,59 @@ +--- +http_interactions: +- request: + method: post + uri: http://FAKE_TACOS_HOST/graphql + body: + encoding: UTF-8 + string: '{ "query": "{ logSearchEvent(searchTerm: \"direct\", sourceSystem: + \"use\" ) { phrase source detectors { suggestedResources { title url } } } + }" }' + headers: + Accept: + - application/json + Content-Type: + - application/json + Connection: + - Keep-Alive + Host: + - FAKE_TACOS_HOST + User-Agent: + - http.rb/5.3.1 + response: + status: + code: 200 + message: OK + headers: + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - '0' + X-Content-Type-Options: + - nosniff + X-Permitted-Cross-Domain-Policies: + - none + Referrer-Policy: + - strict-origin-when-cross-origin + Content-Type: + - application/json; charset=utf-8 + Vary: + - Accept, Origin + Etag: + - W/"a66b90423fc1658bd873263c1f6ab9f6" + Cache-Control: + - max-age=0, private, must-revalidate + X-Request-Id: + - 4b46e2b5-fde0-4de2-b0bb-5363548b47c6 + X-Runtime: + - '0.079767' + Server-Timing: + - start_processing.action_controller;dur=0.01, sql.active_record;dur=4.70, start_transaction.active_record;dur=0.00, + transaction.active_record;dur=12.18, instantiation.active_record;dur=0.11, + process_action.action_controller;dur=42.34 + Content-Length: + - '100' + body: + encoding: UTF-8 + string: '{"data":{"logSearchEvent":{"phrase":"direct","source":"use","detectors":{"suggestedResources":[]}}}}' + recorded_at: Fri, 03 Oct 2025 15:16:35 GMT +recorded_with: VCR 6.3.1 diff --git a/test/vcr_cassettes/tacos_fake_system.yml b/test/vcr_cassettes/tacos_fake_system.yml new file mode 100644 index 00000000..ba5213bc --- /dev/null +++ b/test/vcr_cassettes/tacos_fake_system.yml @@ -0,0 +1,59 @@ +--- +http_interactions: +- request: + method: post + uri: http://FAKE_TACOS_HOST/graphql + body: + encoding: UTF-8 + string: '{ "query": "{ logSearchEvent(searchTerm: \"popcorn\", sourceSystem: + \"faked\" ) { phrase source detectors { suggestedResources { title url } } + } }" }' + headers: + Accept: + - application/json + Content-Type: + - application/json + Connection: + - Keep-Alive + Host: + - FAKE_TACOS_HOST + User-Agent: + - http.rb/5.3.1 + response: + status: + code: 200 + message: OK + headers: + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - '0' + X-Content-Type-Options: + - nosniff + X-Permitted-Cross-Domain-Policies: + - none + Referrer-Policy: + - strict-origin-when-cross-origin + Content-Type: + - application/json; charset=utf-8 + Vary: + - Accept, Origin + Etag: + - W/"035bbed4446f9d4569481bbb5d2f0b6a" + Cache-Control: + - max-age=0, private, must-revalidate + X-Request-Id: + - 9f427731-b972-4ca5-be53-a80a5c8ee2de + X-Runtime: + - '0.023578' + Server-Timing: + - start_processing.action_controller;dur=0.01, sql.active_record;dur=0.94, start_transaction.active_record;dur=0.00, + instantiation.active_record;dur=0.07, transaction.active_record;dur=0.98, + process_action.action_controller;dur=4.86 + Content-Length: + - '103' + body: + encoding: UTF-8 + string: '{"data":{"logSearchEvent":{"phrase":"popcorn","source":"faked","detectors":{"suggestedResources":[]}}}}' + recorded_at: Fri, 03 Oct 2025 13:55:59 GMT +recorded_with: VCR 6.3.1 diff --git a/test/vcr_cassettes/tacos_popcorn.yml b/test/vcr_cassettes/tacos_popcorn.yml new file mode 100644 index 00000000..0002783a --- /dev/null +++ b/test/vcr_cassettes/tacos_popcorn.yml @@ -0,0 +1,59 @@ +--- +http_interactions: +- request: + method: post + uri: http://FAKE_TACOS_HOST/graphql + body: + encoding: UTF-8 + string: '{ "query": "{ logSearchEvent(searchTerm: \"popcorn\", sourceSystem: + \"use\" ) { phrase source detectors { suggestedResources { title url } } } + }" }' + headers: + Accept: + - application/json + Content-Type: + - application/json + Connection: + - Keep-Alive + Host: + - FAKE_TACOS_HOST + User-Agent: + - http.rb/5.3.1 + response: + status: + code: 200 + message: OK + headers: + X-Frame-Options: + - SAMEORIGIN + X-Xss-Protection: + - '0' + X-Content-Type-Options: + - nosniff + X-Permitted-Cross-Domain-Policies: + - none + Referrer-Policy: + - strict-origin-when-cross-origin + Content-Type: + - application/json; charset=utf-8 + Vary: + - Accept, Origin + Etag: + - W/"84adabecd4fb001e4a3306daa2b2321e" + Cache-Control: + - max-age=0, private, must-revalidate + X-Request-Id: + - c72d3c64-ee74-4de3-b095-1416ef3f433b + X-Runtime: + - '0.023035' + Server-Timing: + - start_processing.action_controller;dur=0.01, sql.active_record;dur=0.85, start_transaction.active_record;dur=0.00, + instantiation.active_record;dur=0.07, transaction.active_record;dur=0.85, + process_action.action_controller;dur=4.63 + Content-Length: + - '101' + body: + encoding: UTF-8 + string: '{"data":{"logSearchEvent":{"phrase":"popcorn","source":"use","detectors":{"suggestedResources":[]}}}}' + recorded_at: Fri, 03 Oct 2025 13:55:59 GMT +recorded_with: VCR 6.3.1