6 Commits
Author SHA1 Message Date
Tanner ff39918591 Modify search to work with article contents 2026-06-13 11:54:52 -06:00
Tanner 11ed648791 Ignore data.ms.old/ 2026-06-13 11:54:35 -06:00
Tannerandaider eb2d8be765 feat: Add "Search in article" filter checkbox to results page
Co-authored-by: aider (gemini/gemini-2.5-pro) <aider@aider.chat>
2025-12-16 17:06:53 -07:00
Tannerandaider 795c29c07a fix: Extract prose from HTML text field for indexing
Co-authored-by: aider (gemini/gemini-2.5-pro) <aider@aider.chat>
2025-12-12 16:14:36 -07:00
Tannerandaider 643b46d5c4 refactor: Adapt Meilisearch integration to v1.29.0 API
Co-authored-by: aider (gemini/gemini-2.5-pro) <aider@aider.chat>
2025-12-12 13:34:48 -07:00
Tanner 82cc12c70a feat: Add MeiliSearch API key authentication 2025-12-12 13:34:43 -07:00
24 changed files with 315 additions and 1331 deletions
-1
View File
@@ -111,4 +111,3 @@ data.db.bak
data/archive/* data/archive/*
data/backup/* data/backup/*
qotnews.sqlite qotnews.sqlite
praw.ini
+1 -1
View File
@@ -11,7 +11,7 @@ import settings
from feeds import hackernews, reddit, tildes, manual, lobsters from feeds import hackernews, reddit, tildes, manual, lobsters
import utils import utils
INVALID_DOMAINS = ['youtube.com', 'bloomberg.com', 'wsj.com', 'sec.gov', 'joshuamorris.info'] INVALID_DOMAINS = ['youtube.com', 'bloomberg.com', 'wsj.com', 'sec.gov']
TWO_DAYS = 60*60*24*2 TWO_DAYS = 60*60*24*2
def list(): def list():
+67
View File
@@ -0,0 +1,67 @@
import logging
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
import database
from sqlalchemy import select
import search
import sys
import time
import json
import requests
from bs4 import BeautifulSoup
database.init()
search.init()
BATCH_SIZE = 1000
def put_stories(stories):
return search.meili_api(requests.post, 'indexes/qotnews/documents', stories)
def get_update(update_id):
return search.meili_api(requests.get, 'tasks/{}'.format(update_id))
if __name__ == '__main__':
num_stories = database.count_stories()
print('Reindex {} stories?'.format(num_stories))
print('Press ENTER to continue, ctrl-c to cancel')
input()
story_list = database.get_story_list()
count = 1
while len(story_list):
stories = []
for _ in range(BATCH_SIZE):
try:
sid = story_list.pop()
except IndexError:
break
story = database.get_story(sid)
print('Indexing {}/{} id: {} title: {}'.format(count, num_stories, sid[0], story.title))
story_obj = json.loads(story.full_json)
story_obj.pop('comments', False)
if 'text' in story_obj and story_obj['text']:
soup = BeautifulSoup(story_obj['text'], 'html.parser')
story_obj['text'] = soup.get_text()
stories.append(story_obj)
count += 1
res = put_stories(stories)
update_id = res['taskUid']
print('Waiting for processing', end='')
while get_update(update_id)['status'] != 'succeeded':
time.sleep(0.5)
print('.', end='', flush=True)
print()
print('Done.')
+12 -2
View File
@@ -1,6 +1,8 @@
import database import database
import search import search
import sys import sys
import settings
import logging
import json import json
import requests import requests
@@ -20,8 +22,16 @@ def database_del_story(sid):
session.close() session.close()
def search_del_story(sid): def search_del_story(sid):
return search.meili_api( try:
requests.delete, 'indexes/qotnews/documents/' + sid) r = requests.delete(settings.MEILI_URL + 'indexes/qotnews/documents/'+sid, timeout=2)
if r.status_code != 202:
raise Exception('Bad response code ' + str(r.status_code))
return r.json()
except KeyboardInterrupt:
raise
except BaseException as e:
logging.error('Problem deleting MeiliSearch story: {}'.format(str(e)))
return False
if __name__ == '__main__': if __name__ == '__main__':
if len(sys.argv) == 2: if len(sys.argv) == 2:
+6 -18
View File
@@ -11,6 +11,7 @@ import sys
import time import time
import json import json
import requests import requests
from bs4 import BeautifulSoup
database.init() database.init()
search.init() search.init()
@@ -45,30 +46,17 @@ if __name__ == '__main__':
story = database.get_story(sid) story = database.get_story(sid)
print('Indexing {}/{} id: {} title: {}'.format(count, num_stories, sid[0], story.title)) print('Indexing {}/{} id: {} title: {}'.format(count, num_stories, sid[0], story.title))
story_obj = json.loads(story.meta_json) story_obj = json.loads(story.meta_json)
if 'text' in story_obj and story_obj['text']:
soup = BeautifulSoup(story_obj['text'], 'html.parser')
story_obj['text'] = soup.get_text()
stories.append(story_obj) stories.append(story_obj)
count += 1 count += 1
res = put_stories(stories) res = put_stories(stories)
if not isinstance(res, dict): update_id = res['uid']
raise RuntimeError('Meilisearch failed to enqueue documents: {}'.format(res))
# Meilisearch task responses expose the asynchronous task ID as taskUid.
update_id = res.get('taskUid') or res.get('uid')
if update_id is None:
raise RuntimeError('Meilisearch response did not include a task ID: {}'.format(res))
print('Waiting for processing', end='') print('Waiting for processing', end='')
while True: while get_update(update_id)['status'] != 'succeeded':
task = get_update(update_id)
if not isinstance(task, dict):
raise RuntimeError('Could not retrieve Meilisearch task {}: {}'.format(update_id, task))
status = task.get('status')
if status == 'succeeded':
break
if status in ('failed', 'canceled'):
raise RuntimeError('Meilisearch task {} {}: {}'.format(update_id, status, task))
time.sleep(0.5) time.sleep(0.5)
print('.', end='', flush=True) print('.', end='', flush=True)
+18 -14
View File
@@ -25,33 +25,37 @@ def meili_api(method, route, json=None, params=None, parse_json=True):
logging.error('Problem with MeiliSearch api route: %s: %s', route, str(e)) logging.error('Problem with MeiliSearch api route: %s: %s', route, str(e))
return False return False
def create_index(index_uid='qotnews'): def update_settings():
json = dict(uid=index_uid, primaryKey='id')
return meili_api(requests.post, 'indexes', json=json)
def update_settings(index_uid='qotnews'):
json = { json = {
'rankingRules': ['typo', 'words', 'proximity', 'date:desc', 'exactness'], 'rankingRules': ['words', 'typo', 'proximity', 'attribute', 'date:desc', 'exactness'],
'searchableAttributes': ['title', 'url', 'author'], 'searchableAttributes': ['title', 'url', 'author', 'text'],
'displayedAttributes': ['id', 'ref', 'source', 'author', 'author_link', 'score', 'date', 'title', 'link', 'url', 'num_comments'], 'displayedAttributes': ['id', 'ref', 'source', 'author', 'author_link', 'score', 'date', 'title', 'link', 'url', 'num_comments', 'text'],
'stopWords': ['a', 'an', 'the', 'and', 'or', 'but', 'if', 'in', 'on', 'at', 'by', 'for', 'with', 'to', 'from', 'of', 'is', 'it', 'that', 'this'],
} }
return meili_api(requests.patch, 'indexes/{}/settings'.format(index_uid), json=json) return meili_api(requests.patch, 'indexes/qotnews/settings', json=json)
def init(): def init():
if not SEARCH_ENABLED: if not SEARCH_ENABLED:
logging.info('Search is not enabled, skipping init.') logging.info('Search is not enabled, skipping init.')
return return
print(create_index())
update_settings() update_settings()
def put_story(story, index_uid='qotnews'): def put_story(story):
if not SEARCH_ENABLED: return if not SEARCH_ENABLED: return
return meili_api(requests.post, 'indexes/{}/documents'.format(index_uid), [story]) return meili_api(requests.post, 'indexes/qotnews/documents', [story])
def search(q, index_uid='qotnews'): def search(q, in_article=False):
if not SEARCH_ENABLED: return [] if not SEARCH_ENABLED: return []
json = dict(q=q, limit=settings.FEED_LENGTH) json = dict(q=q, limit=settings.FEED_LENGTH)
r = meili_api(requests.post, 'indexes/{}/search'.format(index_uid), json=json, parse_json=False)
if True:
json['attributesToSearchOn'] = ['text']
json['attributesToCrop'] = ['text']
json['attributesToRetrieve'] = ['id', 'ref', 'source', 'author', 'author_link', 'score', 'date', 'title', 'link', 'url', 'num_comments']
json['cropLength'] = 80
r = meili_api(requests.post, 'indexes/qotnews/search', json=json, parse_json=False)
return r return r
if __name__ == '__main__': if __name__ == '__main__':
+16 -23
View File
@@ -76,12 +76,8 @@ cors = CORS(flask_app)
def api(): def api():
skip = request.args.get('skip', 0) skip = request.args.get('skip', 0)
limit = request.args.get('limit', settings.FEED_LENGTH) limit = request.args.get('limit', settings.FEED_LENGTH)
is_smallweb_filter = request.args.get('smallweb') == 'true' and smallweb_set
sources_filter = request.args.getlist('source')
if not is_smallweb_filter and not sources_filter: if request.args.get('smallweb') == 'true' and smallweb_set:
stories = database.get_stories(limit, skip)
else:
limit = int(limit) limit = int(limit)
skip = int(skip) skip = int(skip)
filtered_stories = [] filtered_stories = []
@@ -94,28 +90,24 @@ def api():
for story_str in stories_batch: for story_str in stories_batch:
story = json.loads(story_str) story = json.loads(story_str)
story_url = story.get('url') or story.get('link') or ''
if is_smallweb_filter: if not story_url:
story_url = story.get('url') or story.get('link') or '' continue
if not story_url: hostname = urlparse(story_url).hostname
continue if hostname:
hostname = urlparse(story_url).hostname hostname = hostname.replace('www.', '')
if not hostname or hostname.replace('www.', '') not in smallweb_set: if hostname in smallweb_set:
continue filtered_stories.append(story_str)
if len(filtered_stories) == limit:
if sources_filter: break
if story.get('source') not in sources_filter:
continue
filtered_stories.append(story_str)
if len(filtered_stories) == limit:
break
if len(filtered_stories) == limit: if len(filtered_stories) == limit:
break break
current_skip += limit current_skip += limit
stories = filtered_stories stories = filtered_stories
else:
stories = database.get_stories(limit, skip)
# hacky nested json # hacky nested json
res = Response('{"stories":[' + ','.join(stories) + ']}') res = Response('{"stories":[' + ','.join(stories) + ']}')
@@ -139,8 +131,9 @@ def apistats():
@flask_app.route('/api/search', strict_slashes=False) @flask_app.route('/api/search', strict_slashes=False)
def apisearch(): def apisearch():
q = request.args.get('q', '') q = request.args.get('q', '')
in_article = request.args.get('article', False)
if len(q) >= 3: if len(q) >= 3:
results = search.search(q) results = search.search(q, in_article)
else: else:
results = '[]' results = '[]'
res = Response(results) res = Response(results)
@@ -270,7 +263,7 @@ def static_story(sid):
show_comments=request.path.endswith('/c'), show_comments=request.path.endswith('/c'),
) )
http_server = WSGIServer(('', 33842), flask_app) http_server = WSGIServer(('0.0.0.0', 33842), flask_app)
def feed_thread(): def feed_thread():
global news_index, ref_list, current_item global news_index, ref_list, current_item
-1
View File
@@ -14,7 +14,6 @@ NUM_TILDES = 5
# Leave blank if not using search # Leave blank if not using search
#MEILI_URL = 'http://127.0.0.1:7700/' #MEILI_URL = 'http://127.0.0.1:7700/'
MEILI_URL = '' MEILI_URL = ''
MEILI_API_KEY = ''
# Readerserver URL # Readerserver URL
# Leave blank if not using, but that defeats the whole point # Leave blank if not using, but that defeats the whole point
-564
View File
@@ -1,564 +0,0 @@
"""Regression tests for the QotNews API server.
Run unit tests from this directory with ``python tests.py`` (or
``python -m unittest``). They mock network calls and use an in-memory database.
Live integrations are opt-in: run ``QOTNEWS_RUN_INTEGRATION=1 python tests.py``
to call configured services and public feed APIs. The Meilisearch integration
test creates and removes a temporary ``qotnews_test`` index.
"""
import contextlib
import datetime
import io
import json
import os
import sys
import time
import unittest
from types import SimpleNamespace
from unittest import mock
# The application modules use top-level imports (``import settings``), so make
# this file runnable both from apiserver/ and from the repository root.
APISERVER_DIR = os.path.dirname(os.path.abspath(__file__))
if APISERVER_DIR not in sys.path:
sys.path.insert(0, APISERVER_DIR)
import database
import feed
import search
import utils
from feeds import hackernews, lobsters, manual, reddit, tildes
class UtilityTests(unittest.TestCase):
def test_generated_ids_have_expected_length_and_alphabet(self):
value = utils.gen_rand_id()
self.assertEqual(len(value), utils.NUM_ID_CHARS)
self.assertTrue(value.isalpha())
self.assertTrue(value.isupper())
def test_render_markdown_handles_empty_and_formatted_input(self):
self.assertEqual(utils.render_md(''), '')
self.assertIn('<strong>bold</strong>', utils.render_md('**bold**'))
def test_clean_removes_disallowed_markup(self):
cleaned = utils.clean('<p>safe</p><script>alert(1)</script>')
self.assertIn('<p>safe</p>', cleaned)
self.assertNotIn('<script>', cleaned)
class DatabaseTests(unittest.TestCase):
def setUp(self):
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
self.old_engine = database.engine
self.old_session = database.Session
self.engine = create_engine('sqlite:///:memory:')
database.engine = self.engine
database.Session = sessionmaker(bind=self.engine)
database.init()
def tearDown(self):
database.Session = self.old_session
database.engine = self.old_engine
self.engine.dispose()
def test_put_and_get_story_preserves_full_and_metadata_json(self):
story = {
'id': 'ABCD', 'ref': 'ref-1', 'title': 'Test story',
'source': 'manual', 'text': '<p>article</p>', 'comments': [{'text': 'comment'}],
}
database.put_story(story)
stored = database.get_story('ABCD')
self.assertEqual(stored.ref, 'ref-1')
self.assertEqual(json.loads(stored.full_json)['text'], '<p>article</p>')
metadata = json.loads(stored.meta_json)
self.assertEqual(metadata['title'], 'Test story')
self.assertNotIn('text', metadata)
self.assertNotIn('comments', metadata)
def test_put_story_updates_existing_record(self):
database.put_story({'id': 'ABCD', 'ref': 'ref-1', 'title': 'Old title'})
database.put_story({'id': 'ABCD', 'ref': 'ref-1', 'title': 'New title'})
self.assertEqual(database.get_story('ABCD').title, 'New title')
self.assertEqual(database.count_stories(), 1)
def test_reflist_orders_newest_first_and_stories_exclude_untitled(self):
database.put_story({'id': 'AAAA', 'ref': 'one', 'title': 'First'})
database.put_story({'id': 'BBBB', 'ref': 'two'})
database.put_story({'id': 'CCCC', 'ref': 'three', 'title': 'Third'})
database.put_ref('one', 'AAAA', 'hackernews')
database.put_ref('two', 'BBBB', 'reddit')
database.put_ref('three', 'CCCC', 'lobsters')
self.assertEqual([x['ref'] for x in database.get_reflist(10)], ['three', 'two', 'one'])
stories = [json.loads(item) for item in database.get_stories(10)]
self.assertEqual([item['title'] for item in stories], ['Third', 'First'])
def test_delete_ref_and_lookup_by_ref(self):
database.put_story({'id': 'ABCD', 'ref': 'ref-1', 'title': 'Test'})
database.put_ref('ref-1', 'ABCD', 'manual')
self.assertEqual(database.get_story_by_ref('ref-1').sid, 'ABCD')
database.del_ref('ref-1')
self.assertEqual(database.get_reflist(10), [])
# Deleting a feed reference does not delete the story itself.
self.assertIsNotNone(database.get_story('ABCD'))
class FeedTests(unittest.TestCase):
def test_list_combines_enabled_sources_in_configured_order(self):
with mock.patch.multiple(
feed.settings,
NUM_HACKERNEWS=2, NUM_LOBSTERS=1, NUM_REDDIT=1, NUM_TILDES=1,
), mock.patch.object(feed.hackernews, 'feed', return_value=['h1', 'h2']), \
mock.patch.object(feed.lobsters, 'feed', return_value=['l1']), \
mock.patch.object(feed.reddit, 'feed', return_value=['r1']), \
mock.patch.object(feed.tildes, 'feed', return_value=['t1']):
self.assertEqual(feed.list(), [
('h1', 'hackernews'), ('h2', 'hackernews'), ('l1', 'lobsters'),
('r1', 'reddit'), ('t1', 'tildes'),
])
def test_update_story_dispatches_and_merges_source_data(self):
story = {'id': 'ABCD', 'ref': '123', 'source': 'manual'}
source_data = {'title': 'A title', 'date': int(time.time()), 'url': '', 'text': 'body'}
with mock.patch.object(feed.manual, 'story', return_value=source_data):
self.assertTrue(feed.update_story(story))
self.assertEqual(story['title'], 'A title')
self.assertEqual(story['text'], 'body')
def test_update_story_rejects_old_non_manual_articles(self):
story = {'ref': '123', 'source': 'manual'}
source_data = {'title': 'Old', 'date': int(time.time()) - feed.TWO_DAYS - 1, 'url': ''}
with mock.patch.object(feed.manual, 'story', return_value=source_data):
self.assertFalse(feed.update_story(story))
def test_update_story_allows_old_manual_submissions(self):
story = {'ref': 'https://example.com', 'source': 'manual'}
source_data = {'title': 'Old', 'date': int(time.time()) - feed.TWO_DAYS - 1, 'url': ''}
with mock.patch.object(feed.manual, 'story', return_value=source_data):
self.assertTrue(feed.update_story(story, is_manual=True))
def test_update_story_rejects_non_html_content(self):
story = {'ref': '123', 'source': 'manual'}
source_data = {
'title': 'Document', 'date': int(time.time()),
'url': 'https://example.com/file.pdf',
}
with mock.patch.object(feed.manual, 'story', return_value=source_data), \
mock.patch.object(feed, 'get_content_type', return_value='application/pdf'):
self.assertFalse(feed.update_story(story))
def test_update_story_rejects_blocked_domains(self):
story = {'ref': '123', 'source': 'manual'}
source_data = {
'title': 'Article', 'date': int(time.time()),
'url': 'https://www.bloomberg.com/article',
}
with mock.patch.object(feed.manual, 'story', return_value=source_data), \
mock.patch.object(feed, 'get_content_type', return_value='text/html'):
self.assertFalse(feed.update_story(story))
def test_update_story_rejects_filtered_titles(self):
story = {'ref': '123', 'source': 'manual'}
source_data = {
'title': 'A Musk announcement', 'date': int(time.time()),
'url': 'https://example.com/article',
}
with mock.patch.object(feed.manual, 'story', return_value=source_data), \
mock.patch.object(feed, 'get_content_type', return_value='text/html'):
self.assertFalse(feed.update_story(story))
def test_update_story_returns_false_on_source_exception(self):
story = {'ref': '123', 'source': 'manual'}
with mock.patch.object(feed.manual, 'story', side_effect=ValueError('bad response')), \
mock.patch.object(feed.utils, 'alert_tanner'):
self.assertFalse(feed.update_story(story))
def test_get_article_posts_url_and_returns_reader_body_unchanged(self):
article_url = 'https://t0.vc/7/'
reader_body = (
'<div id="readability-page-1" class="page">'
'<p>Fake dog barking for home security while on vacation.</p>'
'<p>I set up a fake dog that barks if my surveillance cameras are triggered.</p>'
'</div>'
)
response = mock.Mock(status_code=200, text=reader_body)
with mock.patch.object(feed.requests, 'post', return_value=response) as post:
self.assertEqual(feed.get_article(article_url), reader_body)
post.assert_called_once_with(
feed.settings.READER_URL,
data={'url': article_url},
timeout=20,
)
class ParserTests(unittest.TestCase):
def test_hackernews_alg_comment_parses_and_counts_nested_comments(self):
item = {
'author': 'parent', 'points': 4, 'created_at_i': 100,
'text': '<p>hello</p>',
'children': [{'author': 'child', 'points': 2, 'created_at_i': 101,
'text': 'reply', 'children': []}],
}
parsed = hackernews.alg_comment(item)
self.assertEqual(parsed['author'], 'parent')
self.assertEqual(len(parsed['comments']), 1)
self.assertEqual(hackernews.alg_comment_count({'author': '', 'comments': [parsed]}), 2)
def test_hackernews_story_parses_algolia_fields(self):
response = {
'type': 'story', 'author': 'alice', 'points': 30,
'created_at_i': 123, 'title': 'HN story', 'url': 'https://example.com',
'children': [],
}
with mock.patch.object(hackernews, 'api', return_value=response):
parsed = hackernews.alg_story('42')
self.assertEqual(parsed['title'], 'HN story')
self.assertEqual(parsed['link'], 'https://news.ycombinator.com/item?id=42')
self.assertEqual(parsed['num_comments'], 0)
def test_hackernews_item_32250487_parses_real_story_and_comment_data(self):
response = {
'id': 32250487,
'type': 'story',
'author': 'tannercollin',
'points': 318,
'created_at_i': 1658930484,
'title': 'Fake Dog for Home Security',
'url': 'https://t0.vc/7/',
'children': [{
'author': 'CoffeeOnWrite',
'points': 0,
'created_at_i': 1658931140,
'text': 'A fake dog can scare off opportunistic pirates.',
'children': [],
}],
}
with mock.patch.object(hackernews, 'api', return_value=response) as api_call:
parsed = hackernews.story('32250487')
api_call.assert_called_once_with(hackernews.ALG_API_ITEM, '32250487')
self.assertEqual(parsed['title'], 'Fake Dog for Home Security')
self.assertEqual(parsed['author'], 'tannercollin')
self.assertEqual(parsed['score'], 318)
self.assertEqual(parsed['date'], 1658930484)
self.assertEqual(parsed['url'], 'https://t0.vc/7/')
self.assertEqual(parsed['num_comments'], 1)
self.assertEqual(parsed['comments'][0]['author'], 'CoffeeOnWrite')
def test_hackernews_story_rejects_non_story_and_low_engagement(self):
with mock.patch.object(hackernews, 'api', return_value={'type': 'comment'}):
self.assertFalse(hackernews.alg_story('42'))
low_engagement = {
'type': 'story', 'author': 'alice', 'points': 1, 'created_at_i': 123,
'title': 'Quiet story', 'url': '', 'children': [],
}
with mock.patch.object(hackernews, 'api', return_value=low_engagement):
self.assertFalse(hackernews.story('42'))
def test_lobsters_unix_parses_timezone_aware_timestamp(self):
timestamp = lobsters.unix('2020-01-02T03:04:05.000-0500')
expected = int(datetime.datetime(2020, 1, 2, 8, 4, 5, tzinfo=datetime.timezone.utc).timestamp())
self.assertEqual(timestamp, expected)
def test_lobsters_comments_are_nested_by_depth(self):
comments = [
{'depth': 0, 'comment': 'root', 'created_at': '2020-01-02T03:04:05.000+0000'},
{'depth': 1, 'comment': 'reply', 'created_at': '2020-01-02T03:04:06.000+0000'},
{'depth': 0, 'comment': 'another root', 'created_at': '2020-01-02T03:04:07.000+0000'},
]
parsed = lobsters.iter_comments(comments)
self.assertEqual(len(parsed), 2)
self.assertEqual(parsed[0]['comments'][0]['text'], 'reply')
self.assertEqual(parsed[1]['comments'], [])
def test_manual_story_extracts_title_from_html(self):
with mock.patch.object(manual, 'api', return_value='<html><title>Page title</title></html>'):
parsed = manual.story('https://example.com')
self.assertEqual(parsed['title'], 'Page title')
self.assertEqual(parsed['url'], 'https://example.com')
self.assertEqual(parsed['comments'], [])
class SearchTests(unittest.TestCase):
def test_meili_api_sends_bearer_token_and_decodes_json(self):
response = mock.Mock(status_code=200)
response.json.return_value = {'uid': 'qotnews'}
with mock.patch.object(search.settings, 'MEILI_URL', 'http://search/'), \
mock.patch.object(search.settings, 'MEILI_API_KEY', 'secret'), \
mock.patch.object(search.requests, 'post', return_value=response) as post:
result = search.meili_api(search.requests.post, 'indexes', json={'uid': 'qotnews'})
self.assertEqual(result, {'uid': 'qotnews'})
self.assertEqual(post.call_args[0][0], 'http://search/indexes')
self.assertEqual(post.call_args.kwargs['headers']['Authorization'], 'Bearer secret')
self.assertEqual(post.call_args.kwargs['timeout'], 4)
def test_meili_api_returns_false_for_http_error(self):
response = mock.Mock(status_code=500)
with mock.patch.object(search.requests, 'get', return_value=response):
self.assertFalse(search.meili_api(search.requests.get, 'health'))
def test_update_settings_uses_patch_and_supports_a_test_index(self):
with mock.patch.object(search, 'meili_api', return_value={'taskUid': 1}) as api_call:
result = search.update_settings('qotnews_test')
self.assertEqual(result, {'taskUid': 1})
self.assertEqual(api_call.call_args.args[0], search.requests.patch)
self.assertEqual(api_call.call_args.args[1], 'indexes/qotnews_test/settings')
settings_payload = api_call.call_args.kwargs['json']
self.assertEqual(settings_payload['searchableAttributes'], ['title', 'url', 'author'])
self.assertIn('id', settings_payload['displayedAttributes'])
self.assertEqual(settings_payload['rankingRules'][3], 'date:desc')
def test_search_forwards_query_and_returns_raw_response(self):
with mock.patch.object(search, 'meili_api', return_value='{"hits":[]}') as api_call:
result = search.search('python')
self.assertEqual(result, '{"hits":[]}')
self.assertEqual(api_call.call_args.args[1], 'indexes/qotnews/search')
self.assertEqual(api_call.call_args.kwargs['json']['q'], 'python')
self.assertFalse(api_call.call_args.kwargs['parse_json'])
class ServerRouteTests(unittest.TestCase):
"""Import the legacy server module with its runtime side effects disabled."""
@classmethod
def setUpClass(cls):
import gevent.monkey
import gevent.pywsgi
cls.bootstrap_patches = [
mock.patch.object(gevent.monkey, 'patch_all'),
mock.patch.object(database, 'init'),
mock.patch.object(search, 'init'),
mock.patch('urllib.request.urlopen', side_effect=OSError('offline test')),
mock.patch('gevent.spawn'),
mock.patch.object(gevent.pywsgi, 'WSGIServer'),
]
for patcher in cls.bootstrap_patches:
patcher.start()
try:
import server
cls.server = server
except Exception:
for patcher in reversed(cls.bootstrap_patches):
patcher.stop()
raise
@classmethod
def tearDownClass(cls):
for patcher in reversed(cls.bootstrap_patches):
patcher.stop()
def setUp(self):
self.client = self.server.flask_app.test_client()
def test_api_returns_stories_as_json(self):
rows = [json.dumps({'id': 'ABCD', 'title': 'First'})]
with mock.patch.object(database, 'get_stories', return_value=rows) as get_stories:
response = self.client.get('/api')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json(), {'stories': [{'id': 'ABCD', 'title': 'First'}]})
get_stories.assert_called_once_with(self.server.settings.FEED_LENGTH, 0)
def test_api_source_filter_pages_until_it_finds_matching_stories(self):
rows = [
json.dumps({'id': 'AAAA', 'source': 'reddit'}),
json.dumps({'id': 'BBBB', 'source': 'hackernews'}),
]
with mock.patch.object(database, 'get_stories', side_effect=[rows, []]) as get_stories:
response = self.client.get('/api?source=hackernews&limit=1')
self.assertEqual(response.get_json(), {'stories': [{'id': 'BBBB', 'source': 'hackernews'}]})
self.assertEqual(get_stories.call_count, 1)
def test_stats_route_reports_counts_and_id_space(self):
with mock.patch.object(database, 'count_stories', return_value=12):
response = self.client.get('/api/stats')
self.assertEqual(response.status_code, 200)
data = response.get_json()
self.assertEqual(data['total_stories'], 12)
self.assertEqual(data['id_space'], 26 ** utils.NUM_ID_CHARS)
self.assertEqual(data['len_ref_list'], 0)
def test_search_route_skips_short_queries(self):
with mock.patch.object(search, 'search', return_value='[{"id":"ABCD"}]') as do_search:
short = self.client.get('/api/search?q=ab')
long = self.client.get('/api/search?q=python')
self.assertEqual(short.get_json(), [])
self.assertEqual(long.get_json(), [{'id': 'ABCD'}])
do_search.assert_called_once_with('python')
def test_story_route_returns_full_story_and_404_for_missing_story(self):
full_json = json.dumps({'id': 'ABCD', 'title': 'A story'})
with mock.patch.object(database, 'get_story', return_value=SimpleNamespace(full_json=full_json)):
response = self.client.get('/api/ABCD')
self.assertEqual(response.get_json(), {'story': {'id': 'ABCD', 'title': 'A story'}})
with mock.patch.object(database, 'get_story', return_value=None):
missing = self.client.get('/api/ZZZZ')
self.assertEqual(missing.status_code, 404)
def test_submit_normalizes_url_and_returns_new_story_id(self):
def update(story, is_manual=False):
story.update({'title': 'Submitted', 'date': int(time.time()), 'url': '', 'text': 'body'})
return True
with mock.patch.object(self.server, 'new_id', return_value='ABCD'), \
mock.patch.object(database, 'get_story_by_ref', return_value=None), \
mock.patch.object(feed, 'update_story', side_effect=update) as update_story, \
mock.patch.object(database, 'put_story') as put_story, \
mock.patch.object(search, 'put_story') as index_story:
response = self.client.post('/api/submit', data={'url': 'example.com/article'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json(), {'nid': 'ABCD'})
self.assertEqual(update_story.call_args.args[0]['ref'], 'http://example.com/article')
put_story.assert_called_once()
index_story.assert_called_once()
def test_submit_reuses_existing_story(self):
with mock.patch.object(self.server, 'new_id', return_value='NEW1'), \
mock.patch.object(database, 'get_story_by_ref', return_value=SimpleNamespace(sid='OLD1')):
response = self.client.post('/api/submit', data={'url': 'https://example.com/article'})
self.assertEqual(response.get_json(), {'nid': 'OLD1'})
def test_submit_returns_bad_request_for_invalid_submission(self):
with contextlib.redirect_stdout(io.StringIO()):
response = self.client.post('/api/submit', data={})
self.assertEqual(response.status_code, 400)
self.assertIn('error', response.get_json())
RUN_INTEGRATION_TESTS = os.environ.get('QOTNEWS_RUN_INTEGRATION') == '1'
@unittest.skipUnless(
RUN_INTEGRATION_TESTS,
'Set QOTNEWS_RUN_INTEGRATION=1 to run tests against live services and public APIs.',
)
class LiveIntegrationTests(unittest.TestCase):
"""Read-only checks against configured services and upstream feed APIs."""
def test_reader_server_reads_t0_article(self):
body = feed.get_article('https://t0.vc/7/')
self.assertTrue(body, 'Reader server returned an empty body')
self.assertIn('readability-page-1', body)
self.assertIn('Fake dog barking for home security while on vacation.', body)
self.assertIn('I set up a fake dog that barks', body)
def test_hackernews_firebase_topstories(self):
story_ids = hackernews.feed()
self.assertTrue(story_ids)
self.assertTrue(all(story_id.isdigit() for story_id in story_ids[:10]))
def test_algolia_parses_hackernews_item_32250487(self):
story = hackernews.story('32250487')
self.assertIsInstance(story, dict)
self.assertEqual(story['title'], 'Fake Dog for Home Security')
self.assertEqual(story['author'], 'tannercollin')
self.assertEqual(story['url'].rstrip('/'), 'https://t0.vc/7')
self.assertGreater(story['num_comments'], 0)
def test_reddit_hot_feed_and_story(self):
story_ids = reddit.feed()
self.assertTrue(story_ids)
story = reddit.story(story_ids[0])
self.assertIsInstance(story, dict)
self.assertTrue(story['title'])
self.assertIn('reddit.com', story['link'])
def test_lobsters_hottest_feed_and_story(self):
story_ids = lobsters.feed()
self.assertTrue(story_ids)
story = lobsters.story(story_ids[0])
self.assertIsInstance(story, dict)
self.assertTrue(story['title'])
self.assertIn('lobste.rs/s/', story['link'])
def test_tildes_topic_listing(self):
topic_ids = tildes.feed()
self.assertTrue(topic_ids)
self.assertTrue(all(topic_id for topic_id in topic_ids[:10]))
def test_manual_parser_reads_t0_article(self):
story = manual.story('https://t0.vc/7/')
self.assertIsInstance(story, dict)
self.assertIn('Fake Dog for Home Security', story['title'])
self.assertEqual(story['url'], 'https://t0.vc/7/')
def test_meilisearch_temporary_index_search_and_cleanup(self):
index_uid = 'qotnews_test'
index_url = search.settings.MEILI_URL.rstrip('/') + '/indexes/' + index_uid
headers = {'Authorization': 'Bearer ' + search.settings.MEILI_API_KEY}
existing = search.requests.get(index_url, headers=headers, timeout=5)
if existing.status_code == 200:
self.fail('Refusing to overwrite or delete the existing qotnews_test index')
self.assertEqual(existing.status_code, 404, existing.text)
create_task_uid = None
try:
created = search.create_index(index_uid)
self.assertIsInstance(created, dict)
create_task_uid = created.get('taskUid')
self.assertIsNotNone(create_task_uid, created)
self._wait_for_meili_task(create_task_uid)
settings_task = search.update_settings(index_uid)
self.assertIsInstance(settings_task, dict)
self._wait_for_meili_task(settings_task['taskUid'])
document = {
'id': 'qotnews_test_doc',
'title': 'qotnews integration unique marker',
'url': 'https://example.com/integration-test',
'author': 'integration-test',
'text': 'this field should not be searchable or displayed',
}
add_task = search.put_story(document, index_uid)
self.assertIsInstance(add_task, dict)
self._wait_for_meili_task(add_task['taskUid'])
raw_results = search.search('qotnews integration unique marker', index_uid)
self.assertIsInstance(raw_results, str)
results = json.loads(raw_results)
self.assertEqual(results['hits'][0]['id'], document['id'])
self.assertEqual(results['hits'][0]['title'], document['title'])
self.assertNotIn('text', results['hits'][0])
finally:
# Even failed assertions should not leave test documents or indexes behind.
current = search.requests.get(index_url, headers=headers, timeout=5)
if current.status_code == 200:
deleted = search.meili_api(search.requests.delete, 'indexes/' + index_uid)
self.assertIsInstance(deleted, dict)
self.assertIn('taskUid', deleted)
self._wait_for_meili_task(deleted['taskUid'])
elif current.status_code != 404:
self.fail('Could not verify test index before cleanup: {}'.format(current.text))
after_cleanup = search.requests.get(index_url, headers=headers, timeout=5)
self.assertEqual(after_cleanup.status_code, 404, after_cleanup.text)
def _wait_for_meili_task(self, task_uid, timeout=30):
deadline = time.time() + timeout
while time.time() < deadline:
task = search.meili_api(search.requests.get, 'tasks/{}'.format(task_uid))
self.assertIsInstance(task, dict, 'Could not read Meilisearch task {}'.format(task_uid))
status = task.get('status')
if status in ('succeeded', 'completed'):
return task
if status in ('failed', 'canceled'):
self.fail('Meilisearch task {} {}: {}'.format(task_uid, status, task))
time.sleep(0.25)
self.fail('Timed out waiting for Meilisearch task {}'.format(task_uid))
if __name__ == '__main__':
unittest.main()
+1
View File
@@ -4,3 +4,4 @@
meilisearch-linux-amd64 meilisearch-linux-amd64
data.ms/ data.ms/
data.ms.old/
+1 -1
View File
@@ -3,7 +3,7 @@
Download MeiliSearch with: Download MeiliSearch with:
``` ```
wget https://github.com/meilisearch/meilisearch/releases/download/v1.13.2/meilisearch-linux-amd64 wget https://github.com/meilisearch/meilisearch/releases/download/v0.27.0/meilisearch-linux-amd64
chmod +x meilisearch-linux-amd64 chmod +x meilisearch-linux-amd64
``` ```
+81 -106
View File
@@ -30,11 +30,7 @@
--> -->
<title>{{ title }}</title> <title>{{ title }}</title>
<script>document.documentElement.className = 'js-enabled';</script>
<style> <style>
.js-enabled .static-content {
display: none;
}
html { html {
overflow-y: scroll; overflow-y: scroll;
} }
@@ -45,119 +41,98 @@
</head> </head>
<body> <body>
<script>
(function() {
try {
var theme = localStorage.getItem('theme');
if (theme === 'dark') {
document.body.style.backgroundColor = '#1a1a1a';
} else if (theme === 'black' || theme === 'red') {
document.body.style.backgroundColor = '#000';
}
} catch (e) {}
})();
</script>
<div id="root"> <div id="root">
<div class="static-content"> <div class="container menu">
<p>
{% if False %} <a href="/">QotNews</a>
<noscript> <br />
<meta http-equiv="refresh" content="0;url=?/no.script"> <span class="slogan">Hacker News, Reddit, Lobsters, and Tildes articles rendered in reader mode.</span>
</noscript> </p>
{% endif %} </div>
{% if story %}
<div class="container menu"> <div class="{% if show_comments %}container{% else %}article-container{% endif %}">
<p> <div class="article">
<a href="/">QotNews</a> <h1>{{ story.title }}</h1>
<br />
<span class="slogan">Hacker News, Reddit, Lobsters, and Tildes articles rendered in reader mode.</span>
</p>
</div>
{% if story %}
<div class="{% if show_comments %}container{% else %}article-container{% endif %}">
<div class="article">
<h1>{{ story.title }}</h1>
{% if show_comments %}
<div class="info">
<a href="/{{ story.id }}">View article</a>
</div>
{% else %}
<div class="info">
Source: <a class="source" href="{{ story.url or story.link }}">{{ url }}</a>
</div>
{% endif %}
{% if show_comments %}
<div class="info"> <div class="info">
<a href="/{{ story.id }}">View article</a>
</div>
{% else %}
<div class="info">
Source: <a class="source" href="{{ story.url or story.link }}">{{ url }}</a>
</div>
{% endif %}
<div class="info">
{{ story.score }} points
by <a href="{{ story.author_link }}">{{ story.author }}</a>
{{ story.date | fromnow }}
on <a href="{{ story.link }}">{{ story.source }}</a> |
<a href="/{{ story.id }}/c">
{{ story.num_comments }} comment{{ 's' if story.num_comments != 1 }}
</a>
</div>
{% if not show_comments and story.text %}
<div class="story-text">{{ story.text | safe }}</div>
{% elif show_comments %}
{% macro render_comment(comment, level) %}
<dt></dt>
<dd class="comment{% if level > 0 %} lined{% endif %}">
<div class="info">
<p>
{% if comment.author == story.author %}[OP] {% endif %}{{ comment.author or '[Deleted]' }} | <a href="#{{ comment.author }}{{ comment.date }}" id="{{ comment.author }}{{ comment.date }}">{{ comment.date | fromnow }}</a>
</p>
</div>
<div class="text">{{ (comment.text | safe) if comment.text else '<p>[Empty / deleted comment]</p>' }}</div>
{% if comment.comments %}
<dl>
{% for reply in comment.comments %}
{{ render_comment(reply, level + 1) }}
{% endfor %}
</dl>
{% endif %}
</dd>
{% endmacro %}
<dl class="comments">
{% for comment in story.comments %}{{ render_comment(comment, 0) }}{% endfor %}
</dl>
{% endif %}
</div>
<div class='dot toggleDot'>
<div class='button'>
<a href="/{{ story.id }}{{ '/c' if not show_comments else '' }}">
{{ '' if not show_comments else '' }}
</a>
</div>
</div>
</div>
{% elif stories %}
<div class="container">
{% for story in stories %}
<div class='item'>
<div class='title'>
<a class='link' href='/{{ story.id }}'>
<img class='source-logo' src='/logos/{{ story.source }}.png' alt='{{ story.source }}:' /> {{ story.title }}
</a>
<span class='source'>
(<a class='source' href='{{ story.url or story.link }}'>{{ story.hostname }}</a>)
</span>
</div>
<div class='info'>
{{ story.score }} points {{ story.score }} points
by <a href="{{ story.author_link }}">{{ story.author }}</a> by <a href="{{ story.author_link }}">{{ story.author }}</a>
{{ story.date | fromnow }} {{ story.date | fromnow }}
on <a href="{{ story.link }}">{{ story.source }}</a> | on <a href="{{ story.link }}">{{ story.source }}</a> |
<a href="/{{ story.id }}/c"> <a class="{{ 'hot' if story.num_comments > 99 else '' }}" href="/{{ story.id }}/c">
{{ story.num_comments }} comment{{ 's' if story.num_comments != 1 }} {{ story.num_comments }} comment{{ 's' if story.num_comments != 1 }}
</a> </a>
</div> </div>
{% if not show_comments and story.text %}
<div class="story-text">{{ story.text | safe }}</div>
{% elif show_comments %}
{% macro render_comment(comment, level) %}
<dt></dt>
<dd class="comment{% if level > 0 %} lined{% endif %}">
<div class="info">
<p>
{% if comment.author == story.author %}[OP] {% endif %}{{ comment.author or '[Deleted]' }} | <a href="#{{ comment.author }}{{ comment.date }}" id="{{ comment.author }}{{ comment.date }}">{{ comment.date | fromnow }}</a>
</p>
</div>
<div class="text">{{ (comment.text | safe) if comment.text else '<p>[Empty / deleted comment]</p>' }}</div>
{% if comment.comments %}
<dl>
{% for reply in comment.comments %}
{{ render_comment(reply, level + 1) }}
{% endfor %}
</dl>
{% endif %}
</dd>
{% endmacro %}
<dl class="comments">
{% for comment in story.comments %}{{ render_comment(comment, 0) }}{% endfor %}
</dl>
{% endif %}
</div> </div>
<div class='dot toggleDot'> {% endfor %}
<div class='button'> </div>
<a href="/{{ story.id }}{{ '/c' if not show_comments else '' }}"> {% endif %}
{{ '' if not show_comments else '' }}
</a>
</div>
</div>
</div>
{% elif stories %}
<div class="container">
{% for story in stories %}
<div class='item'>
<div class='title'>
<a class='link' href='/{{ story.id }}'>
<img class='source-logo' src='/logos/{{ story.source }}.png' alt='{{ story.source }}:' /> {{ story.title }}
</a>
<span class='source'>
(<a class='source' href='{{ story.url or story.link }}'>{{ story.hostname }}</a>)
</span>
</div>
<div class='info'>
{{ story.score }} points
by <a href="{{ story.author_link }}">{{ story.author }}</a>
{{ story.date | fromnow }}
on <a href="{{ story.link }}">{{ story.source }}</a> |
<a class="{{ 'hot' if story.num_comments > 99 else '' }}" href="/{{ story.id }}/c">
{{ story.num_comments }} comment{{ 's' if story.num_comments != 1 }}
</a>
</div>
</div>
{% endfor %}
</div>
{% endif %}
</div>
</div> </div>
<!-- <!--
This HTML file is a template. This HTML file is a template.
+45 -91
View File
@@ -1,4 +1,4 @@
import React, { useState, useLayoutEffect, useEffect, useRef, useCallback } from 'react'; import React, { useState, useEffect, useRef, useCallback } from 'react';
import { BrowserRouter as Router, Route, Link, Switch } from 'react-router-dom'; import { BrowserRouter as Router, Route, Link, Switch } from 'react-router-dom';
import localForage from 'localforage'; import localForage from 'localforage';
import './Style-light.css'; import './Style-light.css';
@@ -14,40 +14,35 @@ import Search from './Search.js';
import Submit from './Submit.js'; import Submit from './Submit.js';
import Results from './Results.js'; import Results from './Results.js';
import ScrollToTop from './ScrollToTop.js'; import ScrollToTop from './ScrollToTop.js';
import Settings from './Settings.js';
function App() { function App() {
const [theme, setTheme] = useState(localStorage.getItem('theme') || ''); const [theme, setTheme] = useState(localStorage.getItem('theme') || '');
const cache = useRef({}); const cache = useRef({});
const [isFullScreen, setIsFullScreen] = useState(!!document.fullscreenElement); const [isFullScreen, setIsFullScreen] = useState(!!document.fullscreenElement);
const [waitingWorker, setWaitingWorker] = useState(null);
const [settingsOpen, setSettingsOpen] = useState(false);
const defaultBodyFontSize = 1.0;
const [bodyFontSize, setBodyFontSize] = useState(Number(localStorage.getItem('bodyFontSize')) || defaultBodyFontSize);
const [bodyFont, setBodyFont] = useState(localStorage.getItem('bodyFont') || 'Sans Serif');
const [articleFont, setArticleFont] = useState(localStorage.getItem('articleFont') || 'Apparatus SIL');
const [filterSmallweb, setFilterSmallweb] = useState(() => localStorage.getItem('filterSmallweb') === 'true');
const [feedSources, setFeedSources] = useState(() => {
const saved = localStorage.getItem('feedSources');
return saved ? JSON.parse(saved) : {
hackernews: true,
reddit: true,
lobsters: true,
tildes: true,
};
});
const updateCache = useCallback((key, value) => { const updateCache = useCallback((key, value) => {
cache.current[key] = value; cache.current[key] = value;
}, []); }, []);
useEffect(() => { const light = () => {
const onSWUpdate = e => { setTheme('');
setWaitingWorker(e.detail.waiting); localStorage.setItem('theme', '');
}; };
window.addEventListener('swUpdate', onSWUpdate);
return () => window.removeEventListener('swUpdate', onSWUpdate); const dark = () => {
}, []); setTheme('dark');
localStorage.setItem('theme', 'dark');
};
const black = () => {
setTheme('black');
localStorage.setItem('theme', 'black');
};
const red = () => {
setTheme('red');
localStorage.setItem('theme', 'red');
};
useEffect(() => { useEffect(() => {
if (Object.keys(cache.current).length === 0) { if (Object.keys(cache.current).length === 0) {
@@ -59,13 +54,24 @@ function App() {
} }
}, [updateCache]); }, [updateCache]);
const goFullScreen = () => {
if ('wakeLock' in navigator) {
navigator.wakeLock.request('screen');
}
document.body.requestFullscreen({ navigationUI: 'hide' });
};
const exitFullScreen = () => {
document.exitFullscreen();
};
useEffect(() => { useEffect(() => {
const onFullScreenChange = () => setIsFullScreen(!!document.fullscreenElement); const onFullScreenChange = () => setIsFullScreen(!!document.fullscreenElement);
document.addEventListener('fullscreenchange', onFullScreenChange); document.addEventListener('fullscreenchange', onFullScreenChange);
return () => document.removeEventListener('fullscreenchange', onFullScreenChange); return () => document.removeEventListener('fullscreenchange', onFullScreenChange);
}, []); }, []);
useLayoutEffect(() => { useEffect(() => {
if (theme === 'dark') { if (theme === 'dark') {
document.body.style.backgroundColor = '#1a1a1a'; document.body.style.backgroundColor = '#1a1a1a';
} else if (theme === 'black') { } else if (theme === 'black') {
@@ -77,86 +83,34 @@ function App() {
} }
}, [theme]); }, [theme]);
useEffect(() => { const fullScreenAvailable = document.fullscreenEnabled ||
document.documentElement.style.fontSize = `${bodyFontSize}rem`; document.mozFullscreenEnabled ||
}, [bodyFontSize]); document.webkitFullscreenEnabled ||
document.msFullscreenEnabled;
const fontMap = {
'Sans Serif': 'sans-serif',
'Serif': 'serif',
'Apparatus SIL': "'Apparatus SIL', sans-serif"
};
useEffect(() => {
document.body.style.fontFamily = fontMap[bodyFont];
}, [bodyFont]);
useEffect(() => {
const styleId = 'article-font-family-style';
let style = document.getElementById(styleId);
if (!style) {
style = document.createElement('style');
style.id = styleId;
document.head.appendChild(style);
}
style.innerHTML = `.story-text { font-family: ${fontMap[articleFont]} !important; }`;
}, [articleFont]);
return ( return (
<div className={theme}> <div className={theme}>
<Settings
settingsOpen={settingsOpen}
setSettingsOpen={setSettingsOpen}
theme={theme}
setTheme={setTheme}
isFullScreen={isFullScreen}
filterSmallweb={filterSmallweb}
setFilterSmallweb={setFilterSmallweb}
feedSources={feedSources}
setFeedSources={setFeedSources}
bodyFontSize={bodyFontSize}
setBodyFontSize={setBodyFontSize}
defaultBodyFontSize={defaultBodyFontSize}
bodyFont={bodyFont}
setBodyFont={setBodyFont}
articleFont={articleFont}
setArticleFont={setArticleFont}
/>
{waitingWorker &&
<div className='update-banner'>
Client version mismatch, please refresh:{' '}
<button onClick={() => {
waitingWorker.postMessage({ type: 'SKIP_WAITING' });
const reload = () => window.location.reload();
navigator.serviceWorker.addEventListener('controllerchange', reload, { once: true });
// Fallback for when the controller has already changed (ie. in another tab)
navigator.serviceWorker.getRegistration().then(reg => {
if (!reg || !reg.waiting) {
reload();
}
});
}}>
Refresh
</button>
</div>
}
<Router> <Router>
<div className='container menu'> <div className='container menu'>
<p> <p>
<Link to='/'>QotNews</Link> <Link to='/'>QotNews</Link>
<button className="settings-button" onClick={() => setSettingsOpen(true)}>Settings</button> <span className='theme'><a href='#' onClick={() => light()}>Light</a> - <a href='#' onClick={() => dark()}>Dark</a> - <a href='#' onClick={() => black()}>Black</a> - <a href='#' onClick={() => red()}>Red</a></span>
<br /> <br />
<span className='slogan'>Hacker News, Reddit, Lobsters, and Tildes articles rendered in reader mode.</span> <span className='slogan'>Hacker News, Reddit, Lobsters, and Tildes articles rendered in reader mode.</span>
</p> </p>
{fullScreenAvailable &&
<Route path='/(|search)' render={() => !isFullScreen ?
<button className='fullscreen' onClick={() => goFullScreen()}>Enter Fullscreen</button>
:
<button className='fullscreen' onClick={() => exitFullScreen()}>Exit Fullscreen</button>
} />
}
<Route path='/(|search)' component={Search} /> <Route path='/(|search)' component={Search} />
<Route path='/(|search)' component={Submit} /> <Route path='/(|search)' component={Submit} />
</div> </div>
<Route path='/' exact render={(props) => <Feed {...props} updateCache={updateCache} filterSmallweb={filterSmallweb} feedSources={feedSources} />} /> <Route path='/' exact render={(props) => <Feed {...props} updateCache={updateCache} />} />
<Switch> <Switch>
<Route path='/search' component={Results} /> <Route path='/search' component={Results} />
<Route path='/:id' exact render={(props) => <Article {...props} cache={cache.current} />} /> <Route path='/:id' exact render={(props) => <Article {...props} cache={cache.current} />} />
+4 -13
View File
@@ -2,7 +2,7 @@ import React, { useState, useEffect } from 'react';
import { useParams } from 'react-router-dom'; import { useParams } from 'react-router-dom';
import { Helmet } from 'react-helmet'; import { Helmet } from 'react-helmet';
import localForage from 'localforage'; import localForage from 'localforage';
import { sourceLink, similarLink, infoLine, ToggleDot } from './utils.js'; import { sourceLink, infoLine, ToggleDot } from './utils.js';
import Latex from 'react-latex-next'; import Latex from 'react-latex-next';
import 'katex/dist/katex.min.css'; import 'katex/dist/katex.min.css';
@@ -12,7 +12,6 @@ const DANGEROUS_TAGS = ['svg', 'math'];
const latexDelimiters = [ const latexDelimiters = [
{ left: '$$', right: '$$', display: true }, { left: '$$', right: '$$', display: true },
{ left: '\\[', right: '\\]', display: true }, { left: '\\[', right: '\\]', display: true },
{ left: '$', right: '$', display: false },
{ left: '\\(', right: '\\)', display: false } { left: '\\(', right: '\\)', display: false }
]; ];
@@ -106,7 +105,7 @@ function Article({ cache }) {
if (v.nodeName === '#text') { if (v.nodeName === '#text') {
const text = v.data; const text = v.data;
if (text.includes('\\[') || text.includes('\\(') || text.includes('$$') || /\$(?:[^$]*[^\s$])\$/.test(text)) { if (text.includes('\\[') || text.includes('\\(') || text.includes('$$')) {
return <Latex key={key} delimiters={latexDelimiters}>{text}</Latex>; return <Latex key={key} delimiters={latexDelimiters}>{text}</Latex>;
} }
@@ -138,8 +137,7 @@ function Article({ cache }) {
const textContent = v.textContent.trim(); const textContent = v.textContent.trim();
const isMath = (textContent.startsWith('\\(') && textContent.endsWith('\\)')) || const isMath = (textContent.startsWith('\\(') && textContent.endsWith('\\)')) ||
(textContent.startsWith('\\[') && textContent.endsWith('\\]')) || (textContent.startsWith('\\[') && textContent.endsWith('\\]')) ||
(textContent.startsWith('$$') && textContent.endsWith('$$')) || (textContent.startsWith('$$') && textContent.endsWith('$$'));
(textContent.startsWith('$') && textContent.endsWith('$') && textContent.indexOf('$') !== textContent.lastIndexOf('$') && !/\s/.test(textContent.charAt(textContent.length - 2)));
const props = { key: key }; const props = { key: key };
if (v.hasAttributes()) { if (v.hasAttributes()) {
@@ -159,13 +157,6 @@ function Article({ cache }) {
const firstParen = mathContent.indexOf('\\('); const firstParen = mathContent.indexOf('\\(');
const lastParen = mathContent.lastIndexOf('\\)'); const lastParen = mathContent.lastIndexOf('\\)');
mathContent = mathContent.substring(0, firstParen) + '\\[' + mathContent.substring(firstParen + 2, lastParen) + '\\]' + mathContent.substring(lastParen + 2); mathContent = mathContent.substring(0, firstParen) + '\\[' + mathContent.substring(firstParen + 2, lastParen) + '\\]' + mathContent.substring(lastParen + 2);
} else if (trimmed.startsWith('$') && !trimmed.startsWith('$$')) {
// Replace $ with $$
const firstDollar = mathContent.indexOf('$');
const lastDollar = mathContent.lastIndexOf('$');
if (firstDollar !== lastDollar) {
mathContent = mathContent.substring(0, firstDollar) + '$$' + mathContent.substring(firstDollar + 1, lastDollar) + '$$' + mathContent.substring(lastDollar + 1);
}
} }
} }
return <Tag {...props}><Latex delimiters={latexDelimiters}>{mathContent}</Latex></Tag>; return <Tag {...props}><Latex delimiters={latexDelimiters}>{mathContent}</Latex></Tag>;
@@ -213,7 +204,7 @@ function Article({ cache }) {
<h1>{story.title} <button className='copy-button' onClick={copyLink}>{copyButtonText}</button></h1> <h1>{story.title} <button className='copy-button' onClick={copyLink}>{copyButtonText}</button></h1>
<div className='info'> <div className='info'>
Source: {sourceLink(story)} | {similarLink(story)} Source: {sourceLink(story)}
</div> </div>
{infoLine(story)} {infoLine(story)}
+17 -35
View File
@@ -1,49 +1,26 @@
import React, { useState, useEffect, useRef } from 'react'; import React, { useState, useEffect } from 'react';
import { Link } from 'react-router-dom'; import { Link } from 'react-router-dom';
import { Helmet } from 'react-helmet'; import { Helmet } from 'react-helmet';
import localForage from 'localforage'; import localForage from 'localforage';
import { sourceLink, infoLine, logos } from './utils.js'; import { sourceLink, infoLine, logos } from './utils.js';
function Feed({ updateCache, filterSmallweb, feedSources }) { function Feed({ updateCache }) {
const [stories, setStories] = useState(() => JSON.parse(localStorage.getItem('stories')) || false); const [stories, setStories] = useState(() => JSON.parse(localStorage.getItem('stories')) || false);
const [error, setError] = useState(''); const [error, setError] = useState('');
const [loadingStatus, setLoadingStatus] = useState(null); const [loadingStatus, setLoadingStatus] = useState(null);
const isInitialMount = useRef(true); const [filterSmallweb, setFilterSmallweb] = useState(() => localStorage.getItem('filterSmallweb') === 'true');
useEffect(() => { const handleFilterChange = e => {
if (isInitialMount.current) { const isChecked = e.target.checked;
isInitialMount.current = false; setStories(false);
} else { setFilterSmallweb(isChecked);
setStories(false); localStorage.setItem('filterSmallweb', isChecked);
} };
}, [filterSmallweb, feedSources]);
useEffect(() => { useEffect(() => {
const controller = new AbortController(); const controller = new AbortController();
if ('serviceWorker' in navigator) { fetch(filterSmallweb ? '/api?smallweb=true' : '/api', { signal: controller.signal })
navigator.serviceWorker.getRegistration().then(reg => {
if (reg) {
console.log('Checking for client update...');
reg.update();
}
});
}
const params = new URLSearchParams();
if (filterSmallweb) {
params.append('smallweb', 'true');
}
const allSources = Object.keys(feedSources);
const enabledSources = allSources.filter(key => feedSources[key]);
if (enabledSources.length > 0 && enabledSources.length < allSources.length) {
enabledSources.forEach(source => params.append('source', source));
}
const apiUrl = `/api?${params.toString()}`;
fetch(apiUrl, { signal: controller.signal })
.then(res => { .then(res => {
if (!res.ok) { if (!res.ok) {
throw new Error(`Server responded with ${res.status} ${res.statusText}`); throw new Error(`Server responded with ${res.status} ${res.statusText}`);
@@ -54,7 +31,7 @@ function Feed({ updateCache, filterSmallweb, feedSources }) {
async (result) => { async (result) => {
const newApiStories = result.stories; const newApiStories = result.stories;
const updated = !stories || stories.map(s => s.id).join() !== newApiStories.map(s => s.id).join(); const updated = !stories || !stories.length || stories[0].id !== newApiStories[0].id;
console.log('New stories available:', updated); console.log('New stories available:', updated);
if (!updated) return; if (!updated) return;
@@ -130,7 +107,7 @@ function Feed({ updateCache, filterSmallweb, feedSources }) {
); );
return () => controller.abort(); return () => controller.abort();
}, [updateCache, filterSmallweb, feedSources]); }, [updateCache, filterSmallweb]);
return ( return (
<div className='container'> <div className='container'>
@@ -139,6 +116,11 @@ function Feed({ updateCache, filterSmallweb, feedSources }) {
<meta name="robots" content="index" /> <meta name="robots" content="index" />
</Helmet> </Helmet>
<div style={{marginBottom: '1rem'}}>
<input type="checkbox" id="filter-smallweb" className="checkbox" checked={filterSmallweb} onChange={handleFilterChange} />
<label htmlFor="filter-smallweb">Only Smallweb</label>
</div>
{error && {error &&
<details style={{marginBottom: '1rem'}}> <details style={{marginBottom: '1rem'}}>
<summary>Connection error? Click to expand.</summary> <summary>Connection error? Click to expand.</summary>
+27 -1
View File
@@ -1,6 +1,7 @@
import React, { useState, useEffect } from 'react'; import React, { useState, useEffect } from 'react';
import { Link, useLocation } from 'react-router-dom'; import { Link, useLocation, useHistory } from 'react-router-dom';
import { Helmet } from 'react-helmet'; import { Helmet } from 'react-helmet';
import queryString from 'query-string';
import { sourceLink, infoLine, logos } from './utils.js'; import { sourceLink, infoLine, logos } from './utils.js';
import AbortController from 'abort-controller'; import AbortController from 'abort-controller';
@@ -8,6 +9,19 @@ function Results() {
const [stories, setStories] = useState(false); const [stories, setStories] = useState(false);
const [error, setError] = useState(false); const [error, setError] = useState(false);
const location = useLocation(); const location = useLocation();
const history = useHistory();
const handleFilterChange = e => {
const isChecked = e.target.checked;
const currentQuery = queryString.parse(location.search);
if (isChecked) {
currentQuery.article = 'true';
} else {
delete currentQuery.article;
}
history.push('/search?' + queryString.stringify(currentQuery));
};
useEffect(() => { useEffect(() => {
const controller = new AbortController(); const controller = new AbortController();
@@ -32,11 +46,19 @@ function Results() {
}; };
}, [location.search]); }, [location.search]);
const searchInArticle = queryString.parse(location.search).article === 'true';
return ( return (
<div className='container'> <div className='container'>
<Helmet> <Helmet>
<title>Search Results | QotNews</title> <title>Search Results | QotNews</title>
</Helmet> </Helmet>
<div style={{marginBottom: '1rem'}}>
<input type="checkbox" id="search-in-article" className="checkbox" checked={searchInArticle} onChange={handleFilterChange} />
<label htmlFor="search-in-article">Search in article</label>
</div>
{error && <p>Connection error?</p>} {error && <p>Connection error?</p>}
{stories ? {stories ?
<> <>
@@ -56,6 +78,10 @@ function Results() {
</div> </div>
{infoLine(x)} {infoLine(x)}
{!!x?._formatted &&
<p>{x._formatted.text.replace(/\n/g, ' ')}</p>
}
</div> </div>
) )
: :
+6 -2
View File
@@ -15,7 +15,9 @@ function Search() {
const newSearch = event.target.value; const newSearch = event.target.value;
setSearch(newSearch); setSearch(newSearch);
if (newSearch.length >= 3) { if (newSearch.length >= 3) {
const searchQuery = queryString.stringify({ 'q': newSearch }); const currentQuery = queryString.parse(location.search);
currentQuery.q = newSearch;
const searchQuery = queryString.stringify(currentQuery);
history.replace('/search?' + searchQuery); history.replace('/search?' + searchQuery);
} else { } else {
history.replace('/'); history.replace('/');
@@ -24,7 +26,9 @@ function Search() {
const searchAgain = (event) => { const searchAgain = (event) => {
event.preventDefault(); event.preventDefault();
const searchString = queryString.stringify({ 'q': event.target[0].value }); const currentQuery = queryString.parse(location.search);
currentQuery.q = event.target[0].value;
const searchString = queryString.stringify(currentQuery);
history.push('/search?' + searchString); history.push('/search?' + searchString);
inputRef.current.blur(); inputRef.current.blur();
} }
-191
View File
@@ -1,191 +0,0 @@
import React from 'react';
function Settings({
settingsOpen,
setSettingsOpen,
theme,
setTheme,
isFullScreen,
filterSmallweb,
setFilterSmallweb,
feedSources,
setFeedSources,
bodyFontSize,
setBodyFontSize,
defaultBodyFontSize,
bodyFont,
setBodyFont,
articleFont,
setArticleFont,
}) {
const light = () => {
setTheme('');
localStorage.setItem('theme', '');
};
const dark = () => {
setTheme('dark');
localStorage.setItem('theme', 'dark');
};
const black = () => {
setTheme('black');
localStorage.setItem('theme', 'black');
};
const red = () => {
setTheme('red');
localStorage.setItem('theme', 'red');
};
const handleFilterChange = e => {
const isChecked = e.target.checked;
setFilterSmallweb(isChecked);
localStorage.setItem('filterSmallweb', isChecked);
};
const handleFeedSourceChange = (source) => {
setFeedSources(prevSources => {
const newSources = { ...prevSources, [source]: !prevSources[source] };
localStorage.setItem('feedSources', JSON.stringify(newSources));
return newSources;
});
};
const changeBodyFont = (font) => {
setBodyFont(font);
localStorage.setItem('bodyFont', font);
};
const changeArticleFont = (font) => {
setArticleFont(font);
localStorage.setItem('articleFont', font);
};
const changeBodyFontSize = (amount) => {
const newSize = bodyFontSize + amount;
setBodyFontSize(parseFloat(newSize.toFixed(2)));
localStorage.setItem('bodyFontSize', newSize.toFixed(2));
};
const resetBodyFontSize = () => {
setBodyFontSize(defaultBodyFontSize);
localStorage.removeItem('bodyFontSize');
};
const bodyFontSettingsChanged = bodyFontSize !== defaultBodyFontSize;
const goFullScreen = () => {
if ('wakeLock' in navigator) {
navigator.wakeLock.request('screen');
}
document.body.requestFullscreen({ navigationUI: 'hide' });
};
const exitFullScreen = () => {
document.exitFullscreen();
};
const fullScreenAvailable = document.fullscreenEnabled ||
document.mozFullscreenEnabled ||
document.webkitFullscreenEnabled ||
document.msFullscreenEnabled;
if (!settingsOpen) {
return null;
}
return (
<>
<div className="modal-overlay" onClick={() => setSettingsOpen(false)}></div>
<div className="modal-content" onClick={e => e.stopPropagation()}>
<button className="close-modal-button" onClick={() => setSettingsOpen(false)}>&times;</button>
<h3>Settings</h3>
<div className="setting-group">
<h4>Theme</h4>
<button className={theme === '' ? 'active' : ''} onClick={() => { light(); setSettingsOpen(false); }}>Light</button>
<button className={theme === 'dark' ? 'active' : ''} onClick={() => { dark(); setSettingsOpen(false); }}>Dark</button>
<button className={theme === 'black' ? 'active' : ''} onClick={() => { black(); setSettingsOpen(false); }}>Black</button>
<button className={theme === 'red' ? 'active' : ''} onClick={() => { red(); setSettingsOpen(false); }}>Red</button>
{fullScreenAvailable &&
<div style={{ marginTop: '0.5rem' }}>
{!isFullScreen ?
<button onClick={() => { goFullScreen(); setSettingsOpen(false); }}>Enter Fullscreen</button>
:
<button onClick={() => { exitFullScreen(); setSettingsOpen(false); }}>Exit Fullscreen</button>
}
</div>
}
</div>
<div className="setting-group">
<h4>Feed</h4>
<div className="font-option gap">
<input className="checkbox" type="checkbox" id="filter-smallweb" checked={filterSmallweb} onChange={handleFilterChange} />
<label htmlFor="filter-smallweb">Small websites only</label>
</div>
<div className="font-option">
<input className="checkbox" type="checkbox" id="filter-hackernews" name="feed-source" checked={feedSources.hackernews} onChange={() => handleFeedSourceChange('hackernews')} />
<label htmlFor="filter-hackernews">Hacker News</label>
</div>
<div className="font-option">
<input className="checkbox" type="checkbox" id="filter-reddit" name="feed-source" checked={feedSources.reddit} onChange={() => handleFeedSourceChange('reddit')} />
<label htmlFor="filter-reddit">Reddit</label>
</div>
<div className="font-option">
<input className="checkbox" type="checkbox" id="filter-lobsters" name="feed-source" checked={feedSources.lobsters} onChange={() => handleFeedSourceChange('lobsters')} />
<label htmlFor="filter-lobsters">Lobsters</label>
</div>
<div className="font-option">
<input className="checkbox" type="checkbox" id="filter-tildes" name="feed-source" checked={feedSources.tildes} onChange={() => handleFeedSourceChange('tildes')} />
<label htmlFor="filter-tildes">Tildes</label>
</div>
</div>
<div className="setting-group">
<h4>Font Size</h4>
<button onClick={() => changeBodyFontSize(-0.05)}>-</button>
<span className="font-size-display">{bodyFontSize.toFixed(2)}</span>
<button onClick={() => changeBodyFontSize(0.05)}>+</button>
<button onClick={resetBodyFontSize} disabled={!bodyFontSettingsChanged}>Reset</button>
</div>
<div className="setting-group">
<h4>Body Font</h4>
<div className="font-option">
<input className="checkbox" type="radio" id="body-sans-serif" name="body-font" value="Sans Serif" checked={bodyFont === 'Sans Serif'} onChange={() => changeBodyFont('Sans Serif')} />
<label htmlFor="body-sans-serif">Sans Serif *</label>
</div>
<div className="font-option">
<input className="checkbox" type="radio" id="body-serif" name="body-font" value="Serif" checked={bodyFont === 'Serif'} onChange={() => changeBodyFont('Serif')} />
<label htmlFor="body-serif">Serif</label>
</div>
<div className="font-option">
<input className="checkbox" type="radio" id="body-apparatus" name="body-font" value="Apparatus SIL" checked={bodyFont === 'Apparatus SIL'} onChange={() => changeBodyFont('Apparatus SIL')} />
<label htmlFor="body-apparatus">Apparatus SIL</label>
</div>
</div>
<div className="setting-group">
<h4>Article Font</h4>
<div className="font-option">
<input className="checkbox" type="radio" id="article-sans-serif" name="article-font" value="Sans Serif" checked={articleFont === 'Sans Serif'} onChange={() => changeArticleFont('Sans Serif')} />
<label htmlFor="article-sans-serif">Sans Serif</label>
</div>
<div className="font-option">
<input className="checkbox" type="radio" id="article-serif" name="article-font" value="Serif" checked={articleFont === 'Serif'} onChange={() => changeArticleFont('Serif')} />
<label htmlFor="article-serif">Serif</label>
</div>
<div className="font-option">
<input className="checkbox" type="radio" id="article-apparatus" name="article-font" value="Apparatus SIL" checked={articleFont === 'Apparatus SIL'} onChange={() => changeArticleFont('Apparatus SIL')} />
<label htmlFor="article-apparatus">Apparatus SIL *</label>
</div>
</div>
</div>
</>
);
}
export default Settings;
+2 -28
View File
@@ -13,7 +13,7 @@
.black .menu button, .black .menu button,
.black .story-text button { .black .story-text button {
background-color: #222222; background-color: #444444;
border-color: #bbb; border-color: #bbb;
color: #ddd; color: #ddd;
} }
@@ -69,35 +69,9 @@
} }
.black .checkbox:checked + label::after { .black .checkbox:checked + label::after {
border-color: #eee; border-color: #ddd;
} }
.black .copy-button { .black .copy-button {
color: #828282; color: #828282;
} }
.black .update-banner {
background-color: #333;
color: #ddd;
}
.black .update-banner button {
background-color: #222222;
border-color: #bbb;
color: #ddd;
}
.black .modal-content {
background: #222;
border-color: #828282;
color: #ddd;
}
.black .modal-content button {
background-color: #222222;
border-color: #bbb;
}
.black .modal-content button.active {
background-color: #555;
}
+2 -28
View File
@@ -13,7 +13,7 @@
.dark .menu button, .dark .menu button,
.dark .story-text button { .dark .story-text button {
background-color: #222222; background-color: #444444;
border-color: #bbb; border-color: #bbb;
color: #ddd; color: #ddd;
} }
@@ -65,35 +65,9 @@
} }
.dark .checkbox:checked + label::after { .dark .checkbox:checked + label::after {
border-color: #eee; border-color: #ddd;
} }
.dark .copy-button { .dark .copy-button {
color: #828282; color: #828282;
} }
.dark .update-banner {
background-color: #333;
color: #ddd;
}
.dark .update-banner button {
background-color: #222222;
border-color: #bbb;
color: #ddd;
}
.dark .modal-content {
background: #222;
border-color: #828282;
color: #ddd;
}
.dark .modal-content button {
background-color: #222222;
border-color: #bbb;
}
.dark .modal-content button.active {
background-color: #555;
}
+3 -146
View File
@@ -1,7 +1,6 @@
body { body {
text-rendering: optimizeLegibility; text-rendering: optimizeLegibility;
font-size: 1rem; font: 1rem/1.3 sans-serif;
line-height: 1.3;
color: #000000; color: #000000;
word-break: break-word; word-break: break-word;
font-kerning: normal; font-kerning: normal;
@@ -44,21 +43,6 @@ input {
border-radius: 4px; border-radius: 4px;
} }
.update-banner {
background-color: #ddd;
padding: 0.75rem;
text-align: center;
}
.update-banner button {
margin-left: 1rem;
padding: 0.25rem 0.75rem;
border: 1px solid #828282;
border-radius: 4px;
background-color: transparent;
cursor: pointer;
}
.fullscreen { .fullscreen {
margin: 0.25rem; margin: 0.25rem;
padding: 0.25rem; padding: 0.25rem;
@@ -86,7 +70,6 @@ pre {
.slogan { .slogan {
color: #828282; color: #828282;
margin-bottom: 0.5rem;
} }
.theme { .theme {
@@ -200,8 +183,7 @@ span.source {
} }
.story-text { .story-text {
font-size: 1.2rem; font: 1.2rem/1.5 'Apparatus SIL', sans-serif;
line-height: 1.5;
margin-top: 1em; margin-top: 1em;
} }
@@ -373,132 +355,7 @@ button.comment {
top: 0.2em; top: 0.2em;
width: 0.3rem; width: 0.3rem;
height: 0.6rem; height: 0.6rem;
border-style: solid; border: solid #000;
border-color: #000;
border-width: 0 2px 2px 0; border-width: 0 2px 2px 0;
transform: rotate(45deg); transform: rotate(45deg);
} }
.tooltip .tooltiptext {
visibility: hidden;
width: 140px;
background-color: #555;
color: #fff;
text-align: center;
border-radius: 6px;
padding: 5px 0;
position: absolute;
z-index: 1;
bottom: 110%;
left: 50%;
margin-left: -70px;
opacity: 0;
transition: opacity 0.2s;
font-size: 0.9rem;
line-height: 1.3;
}
.forwardDot .tooltiptext {
left: auto;
right: 0;
margin-left: 0;
}
.tooltip.show-tooltip .tooltiptext {
visibility: visible;
opacity: 1;
}
.settings-button {
float: right;
background: none;
border: none;
padding: 0;
cursor: pointer;
color: inherit;
font: inherit;
}
.modal-overlay {
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
background-color: rgba(0,0,0,0.5);
z-index: 100;
}
.modal-content {
position: absolute;
top: 1rem;
right: 1rem;
background: #eee;
color: #000;
padding: 1rem;
border-radius: 4px;
z-index: 101;
min-width: 250px;
border: 1px solid #828282;
}
.modal-content h3, .modal-content h4 {
margin-top: 0;
margin-bottom: 0.5rem;
}
.modal-content .setting-group {
margin-bottom: 1rem;
}
.modal-content button {
margin-right: 0.5rem;
padding: 0.25rem 0.75rem;
border: 1px solid #828282;
border-radius: 4px;
background-color: transparent;
cursor: pointer;
font: inherit;
color: inherit;
}
.modal-content button:last-child {
margin-right: 0;
}
.modal-content button.active {
background-color: #ccc;
}
.modal-content button:disabled {
opacity: 0.5;
cursor: not-allowed;
}
.modal-content .font-size-display {
display: inline-block;
width: 50px;
text-align: center;
margin: 0 0.25rem;
}
.modal-content .font-option {
margin-bottom: 0.25rem;
}
.modal-content .gap {
margin-bottom: 0.75rem;
}
.close-modal-button {
position: absolute;
top: 0.5rem;
right: 0.75rem;
background: transparent;
border: none;
font-size: 1.5rem;
line-height: 1;
padding: 0;
cursor: pointer;
color: inherit;
}
+2 -28
View File
@@ -22,7 +22,7 @@
.red .menu button, .red .menu button,
.red .story-text button { .red .story-text button {
background-color: #220000; background-color: #440000;
border-color: #b00; border-color: #b00;
color: #b00; color: #b00;
} }
@@ -87,35 +87,9 @@
} }
.red .checkbox:checked + label::after { .red .checkbox:checked + label::after {
border-color: #dd0000; border-color: #aa0000;
} }
.red .copy-button { .red .copy-button {
color: #690000; color: #690000;
} }
.red .update-banner {
background-color: #300;
color: #d00;
}
.red .update-banner button {
background-color: #220000;
border-color: #b00;
color: #d00;
}
.red .modal-content {
background: #100;
border-color: #690000;
color: #b00;
}
.red .modal-content button {
background-color: #220000;
border-color: #b00;
}
.red .modal-content button.active {
background-color: #550000;
}
+1 -7
View File
@@ -3,15 +3,9 @@ import ReactDOM from 'react-dom';
import App from './App'; import App from './App';
import * as serviceWorker from './serviceWorker'; import * as serviceWorker from './serviceWorker';
// version 4
ReactDOM.render(<App />, document.getElementById('root')); ReactDOM.render(<App />, document.getElementById('root'));
// If you want your app to work offline and load faster, you can change // If you want your app to work offline and load faster, you can change
// // unregister() to register() below. Note this comes with some pitfalls. // // unregister() to register() below. Note this comes with some pitfalls.
// // Learn more about service workers: https://bit.ly/CRA-PWA // // Learn more about service workers: https://bit.ly/CRA-PWA
serviceWorker.register({ serviceWorker.unregister();
onUpdate: registration => {
window.dispatchEvent(new CustomEvent('swUpdate', { detail: registration }));
}
});
+3 -30
View File
@@ -1,4 +1,4 @@
import React, { useState } from 'react'; import React from 'react';
import moment from 'moment'; import moment from 'moment';
import { Link } from 'react-router-dom'; import { Link } from 'react-router-dom';
@@ -9,13 +9,6 @@ export const sourceLink = (story) => {
return (<a className='source' href={url}>{host}</a>); return (<a className='source' href={url}>{host}</a>);
}; };
export const similarLink = (story) => {
const url = story.url || story.link;
const urlObj = new URL(url);
const host = urlObj.hostname.replace(/^www\./, '');
return (<Link to={'/search?q="'+host+'"'} className='similar'>similar</Link>);
};
export const infoLine = (story) => export const infoLine = (story) =>
<div className='info'> <div className='info'>
{story.score} points {story.score} points
@@ -39,8 +32,6 @@ export const ToggleDot = ({ id, article }) => (
); );
export const BackwardDot = () => { export const BackwardDot = () => {
const [showTooltip, setShowTooltip] = useState(false);
const goBackward = () => { const goBackward = () => {
localStorage.setItem('scrollLock', 'True'); localStorage.setItem('scrollLock', 'True');
window.history.back(); window.history.back();
@@ -51,25 +42,15 @@ export const BackwardDot = () => {
if (!document.fullscreenElement) return null; if (!document.fullscreenElement) return null;
return ( return (
<div <div className='dot backwardDot' onClick={goBackward}>
className={'dot backwardDot tooltip' + (showTooltip ? ' show-tooltip' : '')}
onClick={goBackward}
onMouseEnter={() => setShowTooltip(true)}
onMouseLeave={() => setShowTooltip(false)}
onTouchStart={() => setShowTooltip(true)}
onTouchEnd={() => setShowTooltip(false)}
>
<div className='button'> <div className='button'>
</div> </div>
<span className="tooltiptext">Browser Back</span>
</div> </div>
); );
}; };
export const ForwardDot = () => { export const ForwardDot = () => {
const [showTooltip, setShowTooltip] = useState(false);
const goForward = () => { const goForward = () => {
localStorage.setItem('scrollLock', 'True'); localStorage.setItem('scrollLock', 'True');
window.history.forward(); window.history.forward();
@@ -79,18 +60,10 @@ export const ForwardDot = () => {
if (!isMobile) return null; if (!isMobile) return null;
return ( return (
<div <div className='dot forwardDot' onClick={goForward}>
className={'dot forwardDot tooltip' + (showTooltip ? ' show-tooltip' : '')}
onClick={goForward}
onMouseEnter={() => setShowTooltip(true)}
onMouseLeave={() => setShowTooltip(false)}
onTouchStart={() => setShowTooltip(true)}
onTouchEnd={() => setShowTooltip(false)}
>
<div className='button'> <div className='button'>
</div> </div>
<span className="tooltiptext">Browser Forward</span>
</div> </div>
); );
}; };