Merge pull request #7 from ifosch/add-entry

Leave picot ready for publish to PyPI

Author: ifosch

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) [year] [fullname]
+Copyright (c) 2019 Ignasi Fosch
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Pipfile

@@ -7,6 +7,7 @@ verify_ssl = true
 pytest = "*"
 pycodestyle = "*"
 flake8 = "*"
+autopep8 = "*"
 
 [packages]
 feedparser = "*"

Pipfile.lock

@@ -2,6 +2,13 @@
 
 Picot is a library to read, select and extract information from RSS feeds.
 
+## Installation
+
+You can install it using `pip install` as usual:
+```bash
+pip install picot
+ ```
+
 ## Usage
 
 ### As a module
@@ -33,5 +40,5 @@ entries = picot.feed.Feed(url, format_func=lambda x: '{} {}'.format(x['title'],
 
 While intended to be used as a library, Picot can be invoked as a command line tool to get the titles of the entries in an RSS:
 ```bash
-$ pipenv run bin/picot <RSS URL>
+$ picot <RSS URL>
 ```

README.md

@@ -0,0 +1,26 @@
+class Entry(dict):
+    """This class encapsulates a feed's entry providing formatting.
+
+    Example:
+        entry = Entry(raw_entry)
+        formatted_entry = Entry(
+            raw_entry,
+            format_func=lambda x: '{}'.format(x['title']
+        )
+    """
+
+    def __init__(self, *args, **kwargs):
+        """This initializes the the Entry object with corresponding
+        format function.
+        """
+        super(Entry, self).__init__(args[0])
+        self._format_func = super(Entry, self).__repr__
+        if 'format_func' in kwargs:
+            self._format_func = kwargs['format_func']
+
+    def __repr__(self):
+        """This generates a representation of the entry."""
+        if self._format_func is None:
+            return super().__repr__()
+        else:
+            return self._format_func(self)

picot/entry.py

@@ -1,5 +1,7 @@
 import feedparser
 
+from picot.entry import Entry
+
 
 def _ok_to_all_filter(x):
     """This is the default filter function."""
@@ -40,7 +42,8 @@ def _update_entries(self):
         function.
         """
         if self._entries is None:
-            self._entries = [entry for entry in self._feed.entries if
+            self._entries = [Entry(entry, format_func=self.format_func)
+                             for entry in self._feed.entries if
                              self.filter_func(entry)]
 
     def __iter__(self):
@@ -57,11 +60,8 @@ def __len__(self):
         return len(self._entries)
 
     def __repr__(self):
-        """This generates a representation of the feed, according to
-        the format function."""
-        if self.format_func is None:
-            return "{} ({})".format(
-                self._feed.feed.title,
-                self._feed.feed.link
-            )
-        return '\n'.join([self.format_func(entry) for entry in list(self)])
+        """This generates a representation of the feed."""
+        return "{} ({})".format(
+            self._feed.feed.title,
+            self._feed.feed.link
+        )

picot/feed.py

@@ -0,0 +1,39 @@
+import pytest
+
+import picot.entry
+
+
+raw_entry = {
+    'title': 'Some entry',
+    'link': 'https://some.site/entry',
+}
+
+
+@pytest.mark.parametrize(
+    'format_func,expected_output',
+    [
+        (
+            None,
+            repr(raw_entry),
+        ),
+        (
+            lambda x: x['title'],
+            raw_entry['title'],
+        ),
+        (
+            lambda x: '{} {}'.format(x['title'], x['link']),
+            '{} {}'.format(raw_entry['title'], raw_entry['link']),
+        ),
+    ],
+    ids=[
+        'No format function',
+        'Simple format function',
+        'Field combining format function',
+    ],
+)
+def test_entry_format(
+        format_func,
+        expected_output,
+):
+    entry = picot.entry.Entry(raw_entry, format_func=format_func)
+    assert(repr(entry) == expected_output)

test/picot/test_entry.py

@@ -112,62 +112,3 @@ def mocked_parse(url):
     feed = picot.feed.Feed('https://some.url', filter_func=filter_func)
     assert(len(feed) == len(expected_entries))
     assert(list(feed) == expected_entries)
-
-
-@pytest.mark.parametrize(
-    'original_entries,format_func,expected_output',
-    [
-        (
-            single_entry,
-            None,
-            'Feed at https://some.url (https://some.url)',
-        ),
-        (
-            single_entry,
-            lambda x: '',
-            '',
-        ),
-        (
-            single_entry,
-            lambda x: x['title'],
-            'Some entry',
-        ),
-        (
-            multiple_entries,
-            None,
-            'Feed at https://some.url (https://some.url)',
-        ),
-        (
-            multiple_entries,
-            lambda x: '',
-            '''\n''',
-        ),
-        (
-            multiple_entries,
-            lambda x: x['title'],
-            'Some entry\nSome other entry',
-        ),
-    ],
-    ids=[
-        'Single entry - No format',
-        'Single entry - Blank format',
-        'Single entry - Simple format',
-        'Multiple entry - No format',
-        'Multiple entry - Blank format',
-        'Multiple entry - Simple format',
-    ],
-)
-def test_feed_format(
-        original_entries,
-        format_func,
-        expected_output,
-        monkeypatch,
-):
-    def mocked_parse(url):
-        return MockFeed(
-            url,
-            entries=original_entries,
-        )
-    monkeypatch.setattr(feedparser, 'parse', mocked_parse)
-    feed = picot.feed.Feed('https://some.url', format_func=format_func)
-    assert(repr(feed) == expected_output)