manga-tools 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbd23ebbac4de4066358e4f01d81465f87fea705f324dc3de5e4984a61248ab6
-  data.tar.gz: 652062faa457e12a19d5e19baad357483697a2aa1c50c7f1b42b4f141ea39235
+  metadata.gz: b4e6fa4035509554d7e20e8a8eba9c21b813bb8e68dc800b3c44a58419dfa2e0
+  data.tar.gz: 1ae99cc528222dcad3a93cfb36cc34ec86474a157a642f51223ff5b7daa082ac
 SHA512:
-  metadata.gz: 0276b8fb60c70d5d7e3de81c8d3678e4b7ad165668ddaab36570a07e7492b0f1962920ef9887cb3bee8ec5084d3ad414e8407cd361e34d9b0400de506d46566a
-  data.tar.gz: 43344b6b8dbe7d75f9316f0870fa4feb2c1fa8ae127bb3ad3dd72969bb1252d0a3c71b36ecbe7ed84b36ddae58b18df90580493abfeb077a9ac43cb5e1c78c4f
+  metadata.gz: 58d66eea0fd9957cb9a2a563810b4397fb0d476b6d99a7f56b4a3668a22cea0351aa3eca8758d5bf267a04eb7b34c842340ed9e42875750f973eb164157df91e
+  data.tar.gz: a61b64bbf848a173b45a16698e6a7cc7da586a13c0a7c681ebc75555ea958421d3327541258f4b2ea989d5501234df94fb0b3c443be7d43769b775a02fd4b394

data/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: yagihiro
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

data/.rubocop.yml

@@ -19,11 +19,17 @@ AllCops:
   Exclude:
     - 'bin/*'
 
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - 'spec/**/*'
+
 Metrics/AbcSize:
   Max: 37
 
 Metrics/BlockLength:
   Max: 36
+  Exclude:
+    - 'spec/**/*'
 
 Metrics/CyclomaticComplexity:
   Max: 10

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    manga-tools (0.1.3)
+    manga-tools (0.2.0)
       faraday (~> 1.0)
       thor (~> 1.0)
 

data/README.md

@@ -29,6 +29,18 @@ Or install it yourself as:
 $ manga-tools search "ONE PIECE"
 ```
 
+* Follow the specified title
+
+```
+$ manga-tools follow "key"
+```
+
+* Displays a list of the titles you are following
+
+```
+$ manga-tools follow-list
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/manga/tools.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
 require_relative 'tools/cli'
+require_relative 'tools/client'
+require_relative 'tools/formatter'
 require_relative 'tools/http'
+require_relative 'tools/session'
+require_relative 'tools/session_store'
 require_relative 'tools/version'
 
 module Manga

data/lib/manga/tools/cli.rb

@@ -2,27 +2,41 @@
 
 require 'json'
 require 'thor'
-require_relative 'http'
+require_relative 'client'
+require_relative 'formatter'
 
 module Manga
   module Tools
     # CLI class
     class CLI < Thor
+      HOST_OPTION = { aliases: '-h', desc: 'Specifies the host to connect to for development' }.freeze
+
       def self.exit_on_failure?
         true
       end
 
       desc 'search WORD', 'Search titles for a given WORD'
+      method_option :host, HOST_OPTION
       def search(word)
-        url = "https://manga-tools-server.herokuapp.com/publications?keyword=#{CGI.escape(word)}"
-        res = Manga::Tools::Http.get(url)
-        results = JSON.parse(res.body)
+        client = Manga::Tools::Client.new
+        results = client.search(word, options)
+        Manga::Tools::Formatter.display(:search, word, results)
+      end
+
+      desc 'follow KEY', 'Follow a title for a given follow KEY'
+      method_option :host, HOST_OPTION
+      def follow(key)
+        client = Manga::Tools::Client.new
+        results = client.follow(key, options)
+        Manga::Tools::Formatter.display(:follow, key, results)
+      end
 
-        puts "Searching '#{word}' ..."
-        results.each do |item|
-          puts "#{item['published_at']}: #{item['title']}"
-        end
-        puts 'Finished.'
+      desc 'follow-list', 'Displays the follow list'
+      method_option :host, HOST_OPTION
+      def follow_list
+        client = Manga::Tools::Client.new
+        results = client.follow_list(options)
+        Manga::Tools::Formatter.display(:follow_list, results)
       end
     end
   end

data/lib/manga/tools/client.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'json'
+require_relative 'http'
+require_relative 'session'
+
+module Manga
+  module Tools
+    # Client Application class
+    class Client
+      # @return [Manga::Tools::Session] a session instance
+      attr :session
+
+      def initialize
+        @session = Manga::Tools::Session.new
+      end
+
+      # Search `word` with options.
+      # @param word [String] search string
+      # @param options [Hash] command options from Thor
+      def search(word, options)
+        session.options = adapt_to_dev_env(options)
+        session.get("/publications?keyword=#{CGI.escape(word)}")
+      end
+
+      # Follow a title for a given follow `key`
+      # @param key [String] follow key
+      # @param options [Hash] command options from Thor
+      def follow(key, options)
+        params = { key: key }
+        session.options = adapt_to_dev_env(options)
+        session.post('/follows', params)
+      end
+
+      # Displays the follow list
+      # @param options [Hash] command options from Thor
+      def follow_list(options)
+        session.options = adapt_to_dev_env(options)
+        session.get('/follows')
+      end
+
+      private
+
+      def adapt_to_dev_env(options)
+        opts = options.dup
+
+        if opts[:host]
+          # If the `host` option is specified, it is assumed to be the development environment
+          opts[:session_file_name] = 'session-development.txt'
+        end
+
+        opts
+      end
+    end
+  end
+end

data/lib/manga/tools/formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Manga
+  module Tools
+    # Formatter class
+    class Formatter
+      class << self
+        def display(command, *results)
+          case command
+          when :search
+            display_search(results)
+          when :follow
+            display_follow(results)
+          when :follow_list
+            display_follow_list(results)
+          end
+        end
+
+        private
+
+        def display_search(results)
+          puts "Searching '#{results[0]}' ..."
+          results[1].each do |item|
+            puts "#{item['published_at']} [#{item['follow_key']}]: #{item['title']}"
+          end
+          puts 'Finished.'
+        end
+
+        def display_follow(results)
+          puts "Followed '#{results[1]['title']}'."
+          puts 'Finished.'
+        end
+
+        def display_follow_list(results)
+          puts 'Listing follow list...'
+          results[0].each do |item|
+            puts (item['title']).to_s
+          end
+          puts 'Finished.'
+        end
+      end
+    end
+  end
+end

data/lib/manga/tools/http.rb

@@ -9,35 +9,48 @@ module Manga
     # HTTP client class
     module Http
       # @param url [String] an url string, eg: `https://example.com`
+      # @param session_id [String, nil] A Session ID string or nil
       # @return [Faraday::Connection] a connection object
-      def self.connection(url)
-        @connection ||= Faraday.new(
-          url: url,
-          headers: { 'User-Agent' => user_agent }
-        ) do |f|
+      def self.connection(url, session_id)
+        headers = { 'User-Agent' => user_agent }
+        headers['X-Session-ID'] = session_id if session_id
+
+        @connection = Faraday.new(url: url, headers: headers) do |f|
           # f.response :logger
+          f.response :raise_error
         end
       end
 
       # @param url [String] an url string, eg: `https://example.com/path/to/object`
+      # @param session_id [String, nil] A Session ID string or nil
       # @return [Faraday::Response] a response object
-      def self.get(url)
+      def self.get(url, session_id)
         u = URI.parse(url)
-        connection("#{u.scheme}://#{u.host}").get(u.request_uri)
+        connection(connection_url(u), session_id).get(u.request_uri)
       end
 
-      # @param response [Faraday::Response] a response object
-      # @return [nil|Integer] number of second to cache
-      #
-      # supported http header
-      # - cache-control: max-age=[sec]
-      def self.seconds_to_cache(response)
-        result = response['cache-control']&.split(/,/)&.map(&:strip)&.find { |item| item =~ /max-age=(.+)/ }
-        return nil unless result
+      def self.post(url, session_id, params)
+        u = URI.parse(url)
+        connection(connection_url(u), session_id).post do |req|
+          req.headers['Content-Type'] = 'application/json'
+          req.url u.request_uri
+          req.body = params.to_json
+        end
+      end
 
-        Regexp.last_match(1).to_i
+      # @param url [URI] A URL instance.
+      # @return [String] Returns the URL to connect to.
+      #
+      # If the port is not a standard port (80 or 443), the port number is included.
+      def self.connection_url(url)
+        if [80, 443].include?(url.port)
+          "#{url.scheme}://#{url.host}"
+        else
+          "#{url.scheme}://#{url.host}:#{url.port}"
+        end
       end
 
+      # @return [String] Returns a user agent string
       def self.user_agent
         @user_agent ||= "manga-tools #{Manga::Tools::VERSION}"
       end

data/lib/manga/tools/session.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'http'
+require_relative 'session_store'
+
+module Manga
+  module Tools
+    # Network Session class (Session ID handling + HTTP CRUD handling)
+    class Session
+      DEFAULT_HOST = 'https://manga-tools-server.herokuapp.com'
+
+      # @return [Hash] options hash instance
+      attr :options
+
+      # @return [SessionStore] the session store instance
+      attr :store
+
+      def initialize
+        @store = Manga::Tools::SessionStore.new
+        @options = {}
+      end
+
+      def options=(new_options)
+        @base_url = nil
+        @options = new_options
+        store.session_file_name = @options[:session_file_name] if @options[:session_file_name]
+      end
+
+      def get(path)
+        response = with_session { |session_id| Manga::Tools::Http.get(build_full_url(path), session_id) }
+        JSON.parse(response.body)
+      end
+
+      def post(path, params)
+        response = with_session { |session_id| Manga::Tools::Http.post(build_full_url(path), session_id, params) }
+        JSON.parse(response.body)
+      end
+
+      private
+
+      def with_session
+        session_id = store.load
+        res = yield session_id
+        session_id = res.headers['X-Session-ID']
+        store.store(session_id) if session_id
+        res
+      end
+
+      def base_url
+        @base_url ||= options[:host] ? "http://#{options[:host]}" : DEFAULT_HOST
+      end
+
+      def build_full_url(path)
+        "#{base_url}#{path}"
+      end
+    end
+  end
+end

data/lib/manga/tools/session_store.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Manga
+  module Tools
+    # A class on session retention.
+    class SessionStore
+      # @return [String] the session file name string
+      attr_writer :session_file_name
+
+      def initialize
+        create_session_dir_if_necessary
+        @session_file_name = 'session.txt'
+      end
+
+      # Store a session.
+      def store(session_id)
+        return if exists?
+
+        File.open(session_file_path, 'w') do |f|
+          f.write(session_id)
+        end
+      end
+
+      # @return [String, nil] Returns the session ID if the session is stored, otherwise it returns nil
+      def load
+        return nil unless exists?
+
+        File.read(session_file_path)
+      end
+
+      # @return [Boolean] true if the session exists, otherwise returns false.
+      def exists?
+        File.exist?(session_file_path)
+      end
+
+      # @return [String] the session file path
+      def session_file_path
+        "#{session_dir}/#{@session_file_name}"
+      end
+
+      private
+
+      # @return [String] the root directory
+      def root_dir
+        @root_dir ||= "#{Dir.home}/.manga-tools"
+      end
+
+      # @return [String] the session directory
+      def session_dir
+        @session_dir ||= "#{root_dir}/session"
+      end
+
+      def create_session_dir_if_necessary
+        FileUtils.mkdir_p(session_dir)
+      end
+    end
+  end
+end

data/lib/manga/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Manga
   module Tools
-    VERSION = '0.1.3'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: manga-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Hiroki Yagita
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-22 00:00:00.000000000 Z
+date: 2020-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -46,6 +46,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/FUNDING.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
@@ -63,7 +64,11 @@ files:
 - exe/manga-tools
 - lib/manga/tools.rb
 - lib/manga/tools/cli.rb
+- lib/manga/tools/client.rb
+- lib/manga/tools/formatter.rb
 - lib/manga/tools/http.rb
+- lib/manga/tools/session.rb
+- lib/manga/tools/session_store.rb
 - lib/manga/tools/version.rb
 - manga-tools.gemspec
 homepage: https://github.com/yagihiro/manga-tools