random_poetry_scraper 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d58c193c1849127eed0b58051f1ebca61a2b2e0
+  data.tar.gz: 37f25de62e6b6b7874850d45ca49d4f35810f7df
+SHA512:
+  metadata.gz: 4324444b189d84102775c9859b740a43a7e5b2fcfbf5c6e9d506339f7d5c8639ea668106032dc551ecf0e93dd519dbe2d48918dcf220f70bd27a1e3aeb476023
+  data.tar.gz: 809411354811b7779f3922eb3cd7d8ade7068baffdb073b44a67c9f8b08392873dee27b6c556f9a578b0ee955ec9ed9442b9516004ce7111070809ce6baa7830

data/bin/random_poetry_scraper

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "random_poetry_scraper"
+
+CorpusGenerator::CLI.new.call

data/lib/concerns/concerns.rb

@@ -0,0 +1,4 @@
+module CorpusGenerator::Concerns
+    module Displayable
+    end
+end

data/lib/random_poetry_scraper.rb

@@ -0,0 +1,16 @@
+require 'pry'
+require 'nokogiri'
+require 'open-uri'
+require 'trollop'
+require 'json'
+
+require "random_poetry_scraper/version"
+require "concerns/concerns"
+require "random_poetry_scraper/cli"
+require "random_poetry_scraper/poet"
+require "random_poetry_scraper/poem"
+require "random_poetry_scraper/scraper"
+
+module CorpusGenerator
+  # Your code goes here...
+end

data/lib/random_poetry_scraper/cli.rb

@@ -0,0 +1,283 @@
+class CorpusGenerator::CLI
+    attr_accessor :current_poems_alphabetized, :current_poets_alphabetized
+
+    def call(commandline_options = nil)
+        
+        commandline_options = accept_command_line_options if !commandline_options
+
+        if commandline_options == {}
+            handle_no_options_passed_message
+        else
+            if commandline_options[:num_poems] == nil
+                handle_no_num_poems_message
+            elsif commandline_options[:json] && commandline_options[:pleasure]
+                handle_json_and_pleasure_message
+            else
+                handle_valid_command_line_options(commandline_options)
+            end
+        end 
+    end
+
+    def accept_command_line_options
+        opts = Trollop::options do
+            version <<-EOS
+            📖   Random Poetry Scraper
+            Version 1.0 | July 2018
+            Hayden Betts | @hayden_betts
+            EOS
+
+            banner <<~EOS
+            \n📖  Random Poetry Scraper is a command line gem which returns the text of poems scraped from poemhunter.com.
+            \n
+            Usage:
+            \n
+            EOS
+          opt :num_poems, "Number of poems to return", :type => :integer    
+          opt :json, "Output poems and their attributes directly to json"
+          opt :pleasure, "Scrape poems and then enter a CLI for pleasure reading"
+        end
+        opts.select { |k, v| opts[k] }
+    end
+
+    def handle_no_options_passed_message
+        puts ""
+        puts "📖  Random Poetry Scraper requires you to pass in options indicating" 
+        puts "the number of poems you would like to return, and their desired output format." 
+        puts "Run with --help for help."
+        puts ""
+     end
+
+     def handle_json_and_pleasure_message
+        puts "Cannot run with both the --json and --pleasure flags selected"
+        puts "Run with --help for help."
+     end
+
+     def handle_no_num_poems_message
+        puts "Cannot run without a --num-poems selected"
+        puts "Run with --help for help."
+     end
+
+     def handle_valid_command_line_options(commandline_options)
+
+        if commandline_options[:pleasure]
+            get_poems_with_status_updates(commandline_options[:num_poems])
+            pleasure_reading_menu
+        elsif commandline_options[:json]
+            get_poems_without_status_updates(commandline_options[:num_poems])
+            json = CorpusGenerator::Poem.poems_to_json(self.current_poems_alphabetized)
+            puts json
+            return json
+        end
+
+     end
+
+     def get_poems_with_status_updates(num_poems)
+        num_poems.times do |i|
+            poem_attributes = CorpusGenerator::Scraper.new.scrape_poem_page
+
+            # TODO possibly factor out?
+            if poem = CorpusGenerator::Poem.new(poem_attributes)
+                puts "#{i + 1} poem(s) fetched succesfully."
+            else 
+                puts "Failed. Trying again."
+                i -= 1
+            end
+        end
+
+        set_current_poems_alphabetically
+
+     end
+
+     def get_poems_without_status_updates(num_poems)
+        num_poems.times do |i|
+            poem_attributes = CorpusGenerator::Scraper.new.scrape_poem_page
+
+            # TODO possibly factor out?
+            if poem = CorpusGenerator::Poem.new(poem_attributes)
+                next
+            else 
+                i -= 1
+            end
+        end
+
+        set_current_poems_alphabetically
+
+     end
+
+    def set_current_poems_alphabetically
+        self.current_poems_alphabetized = CorpusGenerator::Poem.all.sort_by {|poem| poem.name}
+    end
+
+    ##
+    # => Function to facilitate returning JSON directly
+    ##
+
+    ##
+    # => The pleasure reading interface
+    ##
+
+    def pleasure_reading_menu
+        input = nil
+
+        until input == 'exit'
+
+            pleasure_reading_menu_instructions
+            input = gets.strip
+            
+            case input
+            when 'poems'
+                poem_selection_menu  
+            when 'poets'
+                poet_selection_menu
+            when 'exit'
+                goodbye
+            else
+                puts "Invalid input! Please select a valid option!"
+            end
+        end
+    end
+
+    def poem_selection_menu(poet = nil)
+        input = nil
+
+        while input != 'menu'
+
+            poem_selection_instructions
+            list_current_poems
+
+            input = gets.strip
+            input_valid = input.to_i > 0 && input.to_i <= self.current_poems_alphabetized.size
+ 
+            if input_valid
+                selected_poem = self.current_poems_alphabetized[input.to_i - 1]
+                display_poem(selected_poem)
+                quit_or_continue_reading
+                next
+            elsif input == 'exit'
+                goodbye
+            elsif input != 'menu'
+                puts "Please enter a valid poem selection!"
+            end
+        end
+    end
+
+    def poet_selection_menu
+        input = nil
+
+        while input != 'menu'
+
+            poet_selection_instructions
+            list_poets_alphabetically
+
+            input = gets.strip
+
+            valid_index = input.to_i > 0 && input.to_i <= self.current_poets_alphabetized.size
+
+            if valid_index
+                selected_poet = self.current_poets_alphabetized[input.to_i - 1]
+                set_poems_alphabetically_by_poet(selected_poet)
+                poem_selection_menu
+            elsif input == 'exit'
+                goodbye
+            elsif input != 'menu'
+                puts "Please enter a valid poet selection!"
+            end
+
+            puts "To return to the poet selection menu, enter 'menu'"
+        end
+    end
+
+    ##
+    # => Pleasure Reading Interface General Helpers
+    ##
+
+    def pleasure_reading_menu_instructions
+        puts pleasure_reading_header
+
+        puts "How would you like to find poems to read?"
+        puts "To see a list of poems, type 'poems', and press enter."
+        puts "To see a list of poets, type 'poets', and press enter."
+        puts "To end the program, type 'exit', and press enter."
+        puts ""
+    end
+
+    def pleasure_reading_header
+        header_path = File.join( File.dirname(__FILE__), './pleasure_reading_header' )
+
+        File.read(header_path)
+    end
+
+    def poem_selection_instructions
+        puts "\nType the number of a poem to read it."
+		puts "Or type menu to go up one menu."
+        puts "Or type exit to end the program."
+        puts ""
+    end
+
+    def goodbye
+		puts "Thanks for using Pleasure reader!"
+		exit
+    end
+    
+
+    ##
+    # => Pleasure Reading Interface Poem Selection Menu Helpers
+    ##
+
+    def list_current_poems
+        self.current_poems_alphabetized.each.with_index(1) do |poem, index|
+            puts "#{index}. #{poem.name} - #{poem.poet.name}"
+        end
+        puts ""
+    end
+
+    def display_poem(poem)
+
+        title_string = "#{poem.name} - #{poem.poet.name}"
+
+        puts ""
+        puts Array.new(title_string.length, "*").join('')
+        puts title_string
+        puts Array.new(title_string.length, "*").join('') 
+        puts ""
+        puts "\n#{poem.text}"
+        puts ""
+        puts Array.new(title_string.length, "*").join('') 
+
+    end
+
+    def quit_or_continue_reading
+        puts ""
+        puts "To exit now, type exit"
+        puts "To return to the list of poems, press enter"
+        puts ""
+
+        input = nil
+        input = gets.strip
+        goodbye if input == 'exit'
+    end
+
+    ##
+    # => Pleasure Reading Interface Poet Selection Menu Helpers
+    ##
+
+    def poet_selection_instructions
+        puts ""
+        puts "Type the number of a poet whose poems you would like to read."
+		puts "Or type menu to go up one menu."
+        puts "Or type exit to end the program."
+        puts ""
+    end
+
+    def list_poets_alphabetically
+        self.current_poets_alphabetized = CorpusGenerator::Poet.all.sort_by {|poet| poet.name}
+        self.current_poets_alphabetized.each.with_index(1) do |poet, index|
+            puts "#{index}. #{poet.name}"
+        end
+        puts ""
+    end
+
+    def set_poems_alphabetically_by_poet(selected_poet)
+        self.current_poems_alphabetized = selected_poet.poems.sort_by {|poem| poem.name}
+    end
+end

data/lib/random_poetry_scraper/pleasure_reading_header

@@ -0,0 +1,6 @@
+  ____   _                                       ____                   _             
+ |  _ \ | |  ___   __ _  ___  _   _  _ __  ___  |  _ \  ___   __ _   __| |  ___  _ __ 
+ | |_) || | / _ \ / _` |/ __|| | | || '__|/ _ \ | |_) |/ _ \ / _` | / _` | / _ \| '__|
+ |  __/ | ||  __/| (_| |\__ \| |_| || |  |  __/ |  _ <|  __/| (_| || (_| ||  __/| |   
+ |_|    |_| \___| \__,_||___/ \__,_||_|   \___| |_| \_\\___| \__,_| \__,_| \___||_|   
+                                                                                      

data/lib/random_poetry_scraper/poem.rb

@@ -0,0 +1,53 @@
+class CorpusGenerator::Poem
+    attr_accessor :name, :text, :poet
+
+    @@all = []
+
+    # TODO do you actually want to save all poems as soon
+    # as you initialize them?
+
+    def initialize(attributes_hash)
+        attributes_hash.each do |attribute, value|
+            self.send("#{attribute}=", value)
+        end
+        self.class.all << self
+    end
+
+    # this expects that if there is a poet attribute, it will have a name.
+    # that might hardcode too much knowledge about the structure of the hash?
+    def poet=(poet_attributes)
+        poet = CorpusGenerator::Poet.find_or_create(poet_attributes)
+        @poet = poet
+        poet.add_poem(self)
+    end
+
+    def as_hash
+        {
+            "name" => self.name,
+            "text" => self.text,
+            "poet" => {
+                "name" => self.poet.name,
+                "profile_url" => self.poet.profile_url,
+            } 
+        }
+    end
+
+    # Class Methods
+
+    def self.all
+        @@all
+    end
+    
+    def self.poems_to_hash(poems)
+        poems_hash = {"poems" => []}
+        poems.each do |poem| 
+            poems_hash["poems"] << poem.as_hash
+        end
+        poems_hash
+    end
+
+    def self.poems_to_json(poems)
+        self.poems_to_hash(poems).to_json
+    end
+
+end

data/lib/random_poetry_scraper/poet.rb

@@ -0,0 +1,40 @@
+class CorpusGenerator::Poet
+    attr_accessor :name, :profile_url, :poems
+
+    @@all = []
+
+    def initialize(attributes_hash)
+
+        self.poems = []
+
+        attributes_hash.each do |attribute, value|
+            self.send("#{attribute}=", value)
+        end
+        self.class.all << self
+    end
+
+    def add_poem(poem)
+        self.poems << poem unless self.poems.detect {|poem| poem == self}
+    end
+
+    # Class Methods
+
+    def self.all
+        @@all
+    end
+
+    def self.find_by_name(name)
+        self.all.detect {|poet| poet.name == name}
+    end
+
+
+    def self.find_or_create(attributes)
+        # TODO assumes that there will be a name attribute in hash
+        # ...assumes that a hash will be passed in
+        if poet = self.find_by_name(attributes[:name])
+            return poet
+        else
+            self.new(attributes)
+        end
+    end
+end

data/lib/random_poetry_scraper/scraper.rb

@@ -0,0 +1,22 @@
+class CorpusGenerator::Scraper
+    attr_accessor :html_doc
+    ROOT_LINK = "https://w0.poemhunter.com"
+    BROWSE_LINK = ROOT_LINK + "/members/random-poem/"
+
+    def initialize
+        self.html_doc = Nokogiri::HTML(open(BROWSE_LINK))
+    end
+
+    def scrape_poem_page
+        poem_attributes = {}
+        poem_attributes[:name] = html_doc.css(".poem").css("h2").text
+        poem_attributes[:text] = html_doc.css(".poem").css("p").inner_html.gsub("<br>", "\n").gsub(/\r\n[\t]+/, "")
+        if poet_name = html_doc.css(".poet").text
+            poem_attributes[:poet] = {}
+            poem_attributes[:poet][:name] = poet_name
+            poem_attributes[:poet][:profile_url] = ROOT_LINK + html_doc.css(".poem a").attr("href").value
+        end
+
+        poem_attributes == [] ? nil : poem_attributes
+    end
+end

data/lib/random_poetry_scraper/version.rb

@@ -0,0 +1,2 @@
+module CorpusGenerator
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: random_poetry_scraper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hayden Betts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Random Poetry Scraper is a command line gem which returns the the attributes
+  of a configurable number of poems scraped from poemhunter.com. The gem allows you
+  to consume the poems either through a JSON dump or through a command line "pleasure
+  reading" interface.
+email: haydenbetts@gmail.com
+executables:
+- random_poetry_scraper
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/random_poetry_scraper
+- lib/concerns/concerns.rb
+- lib/random_poetry_scraper.rb
+- lib/random_poetry_scraper/cli.rb
+- lib/random_poetry_scraper/pleasure_reading_header
+- lib/random_poetry_scraper/poem.rb
+- lib/random_poetry_scraper/poet.rb
+- lib/random_poetry_scraper/scraper.rb
+- lib/random_poetry_scraper/version.rb
+homepage: https://github.com/haydenbetts/poetry-scraper-cli-app
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Scrape and return a configurable number of random poems from poemhunter.com/
+test_files: []