pixiv 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tomoki Aonuma
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Pixiv gem
+
+A client library for [pixiv](http://www.pixiv.net/)
+
+## Important Note
+
+The pixiv Guidelines [[en][Guidelines.en], [ja][Guidelines.ja]] prohibit to
+crawl the pixiv service. Do not abuse this library or you may be banned!
+
+[Guidelines.en]: http://www.pixiv.net/guideline.php?lang=en
+[Guidelines.ja]: http://www.pixiv.net/guideline.php?lang=ja
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pixiv', github: 'uasi/pixiv'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+See [a sample script](https://gist.github.com/4362297)
+
+## Documentation
+
+[Documentation for uasi/pixiv on rubydoc.info](http://rubydoc.info/github/uasi/pixiv/master/frames)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/pixiv.rb

@@ -0,0 +1,17 @@
+require 'mechanize'
+require 'pixiv/error'
+require 'pixiv/client'
+require 'pixiv/page'
+require 'pixiv/illust'
+require 'pixiv/member'
+require 'pixiv/page_collection'
+require 'pixiv/bookmark_list'
+
+module Pixiv
+  ROOT_URL = 'http://www.pixiv.net'
+
+  # Delegates to {Pixiv::Client#initialize}
+  def self.new(*args, &block)
+    Pixiv::Client.new(*args, &block)
+  end
+end

data/lib/pixiv/bookmark_list.rb

@@ -0,0 +1,60 @@
+module Pixiv
+  class BookmarkList < Page
+    include PageCollection
+
+    # Returns the URL for given +member_id+ and +page_num+
+    # @param [Integer] member_id
+    # @param [Integer] page_num
+    # @return [String]
+    def self.url(member_id, page_num = 1)
+      "#{ROOT_URL}/bookmark.php?id=#{member_id}&rest=show&p=#{page_num}"
+    end
+
+    # @return [Integer]
+    lazy_attr_reader(:page_num) { at!('li.pages-current').inner_text.to_i }
+    # @return [Boolean]
+    lazy_attr_reader(:last?) { at!('li.pages-current').next_element.inner_text.to_i == 0 }
+    # @return [Integer]
+    lazy_attr_reader(:member_id) { doc.body.match(/pixiv\.context\.userId = '(\d+)'/).to_a[1].to_i }
+    # @return [Array<Integer>]
+    lazy_attr_reader(:illust_ids) { search!('li[id^="li_"] a[href^="member_illust.php?mode=medium"]').map {|n| n.attr('href').match(/illust_id=(\d+)$/).to_a[1].to_i } }
+    # @return [Array<Hash{Symbol=>Object}>]
+    lazy_attr_reader(:illust_hashes) {
+      search!('li[id^="li_"]').map {|node| illust_hash_from_bookmark_item(node) }.compact
+    }
+
+    alias page_hashes illust_hashes
+
+    # @return [String]
+    def url; self.class.url(member_id, page_num) end
+    # @return [Boolean]
+    def first?; page_num == 1 end
+    # @return [String]
+    def next_url; last? ? nil : self.class.url(member_id, page_num + 1) end
+    # @return [String]
+    def prev_url; first? ? nil : self.class.url(member_id, page_num - 1) end
+    # @return [Class<Pixiv::Page>]
+    def page_class; Illust end
+    # @return [Array<String>]
+    def page_urls; illust_ids.map {|illust_id| Illust.url(illust_id) } end
+
+    private
+
+    # @param [Nokogiri::HTML::Node] node
+    # @return [Hash{Symbol=>Object}] illust_hash
+    def illust_hash_from_bookmark_item(node)
+      return nil if node.at('img[src*="limit_unknown_s.png"]')
+      member_node = node.at('a[href^="member_illust.php?id="]')
+      illust_node = node.at('a')
+      illust_id = illust_node['href'].match(/illust_id=(\d+)/).to_a[1].to_i
+      {
+        url: Illust.url(illust_id),
+        illust_id: illust_id,
+        title: illust_node.inner_text,
+        member_id: member_node['href'].match(/\?id=(\d+)/).to_a[1].to_i,
+        member_name: member_node.inner_text,
+        small_image_url: illust_node.at('img').attr('src'),
+      }
+    end
+  end
+end

data/lib/pixiv/client.rb

@@ -0,0 +1,157 @@
+module Pixiv
+  class Client
+    # A new agent
+    # @return [Mechanize::HTTP::Agent]
+    def self.new_agent
+      agent = Mechanize.new
+      agent.pluggable_parser['image/gif'] = Mechanize::Download
+      agent.pluggable_parser['image/jpeg'] = Mechanize::Download
+      agent.pluggable_parser['image/png'] = Mechanize::Download
+      agent
+    end
+
+    # @return [Mechanize::HTTP::Agent]
+    attr_reader :agent
+    # @return [Integer]
+    attr_reader :member_id
+
+    # A new instance of Client, logged in with the given credentials
+    # @overload initialize(pixiv_id, password)
+    #   @param [String] pixiv_id
+    #   @param [String] password
+    #   @yield [agent] (optional) gives a chance to customize the +agent+ before logging in
+    # @overload initialize(agent)
+    #   @param [Mechanize::HTTP::Agent] agent
+    # @return [Pixiv::Client]
+    def initialize(*args)
+      if args.size < 2
+        @agent = args.first || self.class.new_agent
+        yield @agent if block_given?
+        ensure_logged_in
+      else
+        pixiv_id, password = *args
+        @agent = self.class.new_agent
+        yield @agent if block_given?
+        login(pixiv_id, password)
+      end
+    end
+
+    # Log in to Pixiv
+    # @param [String] pixiv_id
+    # @param [String] password
+    def login(pixiv_id, password)
+      form = agent.get("#{ROOT_URL}/index.php").forms_with(:class => 'login-form').first
+      raise Error::LoginFailed, 'login form is not available' unless form
+      form.pixiv_id = pixiv_id
+      form.pass = password
+      doc = agent.submit(form)
+      raise Error::LoginFailed unless doc.body =~ /logout/
+      @member_id = member_id_from_mypage(doc)
+    end
+
+    # @param [Integer] illust_id
+    # @return [Pixiv::Illust]
+    def illust(illust_id)
+      attrs = {illust_id: illust_id}
+      Illust.lazy_new(attrs) { agent.get(Illust.url(illust_id)) }
+    end
+
+    # @param [Integer] member_id
+    # @return [Pixiv::Member]
+    def member(member_id = member_id)
+      attrs = {member_id: member_id}
+      Member.lazy_new(attrs) { agent.get(Member.url(member_id)) }
+    end
+
+    # @param [Pixiv::Member, Integer] member_or_member_id
+    # @param [Integer] page_num
+    def bookmark_list(member_or_member_id = member_id, page_num = 1)
+      x = member_or_member_id
+      member_id = x.is_a?(Member) ? x.member_id : x
+      attrs = {member_id: member_id, page_num: page_num}
+      BookmarkList.lazy_new(attrs) { agent.get(BookmarkList.url(member_id, page_num)) }
+    end
+
+    # @param [Pixiv::Member, Integer] member_or_member_id
+    # @param [Integer] page_num
+    def bookmarks(member_or_member_id = member_id, page_num = 1)
+      list = bookmark_list(member_or_member_id, page_num)
+      PageCollection::Enumerator.new(self, list)
+    end
+
+    # Downloads the image to +io_or_filename+
+    # @param [Pixiv::Illust] illust
+    # @param [#write, String, Array<String, Symbol, #call>] io_or_filename io or filename or pattern (see {#filename_from_pattern})
+    # @param [Symbol] size image size (+:small+, +:medium+, or +:original+)
+    def download_illust(illust, io_or_filename, size = :original)
+      size = {:s => :small, :m => :medium, :o => :original}[size] || size
+      url = illust.__send__("#{size}_image_url")
+      referer = case size
+                when :small then nil
+                when :medium then illust.url
+                when :original then illust.original_image_referer
+                else raise ArgumentError, "unknown size `#{size}`"
+                end
+      save_to = io_or_filename
+      if save_to.is_a?(Array)
+        save_to = filename_from_pattern(save_to, illust, url)
+      end
+      FileUtils.mkdir_p(File.dirname(save_to)) unless save_to.respond_to?(:write)
+      @agent.download(url, save_to, [], referer)
+    end
+
+    # Downloads the images to +pattern+
+    # @param [Pixiv::Illust] illust the manga to download
+    # @param [Array<String, Symbol, #call>] pattern pattern (see {#filename_from_pattern})
+    # @note +illust#manga?+ must be +true+
+    def download_manga(illust, pattern)
+      illust.original_image_urls.each do |url|
+        filename = filename_from_pattern(pattern, illust, url)
+        FileUtils.mkdir_p(File.dirname(filename))
+        @agent.download(url, filename, [], illust.original_image_referer)
+      end
+    end
+
+    protected
+
+    def ensure_logged_in
+      doc = agent.get("#{ROOT_URL}/mypage.php")
+      raise Error::LoginFailed unless doc.body =~ /logout/
+      @member_id = member_id_from_mypage(doc)
+    end
+
+    def member_id_from_mypage(doc)
+      doc.at('.profile_area a').attr('href').match(/(\d+)$/).to_a[1].to_i
+    end
+
+    # Generate filename from +pattern+ in context of +illust+ and +url+
+    #
+    # @param [Array<String, Symbol, #call>] pattern
+    # @param [Pixiv::Illust] illust
+    # @param [String] url
+    # @return [String] filename
+    #
+    # The +pattern+ is an array of string, symbol, or object that responds to +#call+.
+    # Each component of the +pattern+ is replaced by the following rules and then
+    # the +pattern+ is concatenated as the returning +filename+.
+    #
+    # * +:image_name+ in the +pattern+ is replaced with the base name of the +url+
+    # * Any other symbol is replaced with the value of +illust.__send__(the_symbol)+
+    # * +#call+-able object is replaced with the value of +the_object.call(illust)+
+    # * String is left as-is
+    def filename_from_pattern(pattern, illust, url)
+      pattern.map {|i|
+        if i == :image_name
+          name = File.basename(url)
+          if name =~ /\.(\w+)\?\d+$/
+            name += '.' + $1
+          end
+          name
+        elsif i.is_a?(Symbol) then illust.__send__(i)
+        elsif i.respond_to?(:call) then i.call(illust)
+        else i
+        end
+      }.join('')
+    end
+  end
+end

data/lib/pixiv/error.rb

@@ -0,0 +1,6 @@
+module Pixiv
+  class Error < StandardError; end
+  class Error::LoginFailed < Error; end
+  class Error::NodeNotFound < Error; end
+end
+

data/lib/pixiv/illust.rb

@@ -0,0 +1,57 @@
+module Pixiv
+  class Illust < Page
+    # Returns the URL for given +illust_id+
+    # @param [Integer] illust_id
+    # @return [String]
+    def self.url(illust_id)
+      "#{ROOT_URL}/member_illust.php?mode=medium&illust_id=#{illust_id}"
+    end
+
+    # @return [String]
+    lazy_attr_reader(:small_image_url) { at!('meta[property="og:image"]').attr('content') }
+    # @return [String]
+    lazy_attr_reader(:medium_image_url) { image_url_components.join('_m') }
+    # @return [String]
+    lazy_attr_reader(:original_image_url) { illust? && image_url_components.join('') }
+    # @return [Array<String>]
+    lazy_attr_reader(:original_image_urls) {
+      illust? ? [original_image_url]
+              : (0...num_pages).map {|n| image_url_components.join("_p#{n}") }
+    }
+    # @return [String]
+    lazy_attr_reader(:original_image_referer) { ROOT_URL + '/' + at!('//div[@class="works_display"]/a').attr('href') }
+    # @return [Integer]
+    lazy_attr_reader(:illust_id) { at!('#rpc_i_id').attr('title').to_i }
+    # @return [Integer]
+    lazy_attr_reader(:member_id) { at!('#rpc_u_id').attr('title').to_i }
+    # @return [String]
+    lazy_attr_reader(:member_name) { raise NotImplementError.new('XXX') }
+    # @return [String]
+    lazy_attr_reader(:title) { raise NotImplementError.new('XXX') }
+    # @return [Integer]
+    lazy_attr_reader(:num_pages) {
+      n = at!('//ul[@class="meta"]/li[2]').inner_text.match(/(\d+)P$/).to_a[1]
+      n && n.to_i
+    }
+
+    alias id illust_id
+    alias original_image_referrer original_image_referer # referrer vs. referer
+
+    # @return [String]
+    def url; self.class.url(illust_id) end
+    # @return [Boolean]
+    def illust?; !manga? end
+    # @return [Boolean]
+    def manga?; !!num_pages end
+    # @return [String]
+    def medium_image_url; image_url_components.join('_m') end
+    # @return [String]
+    def original_image_url; image_url_components.join('') end
+
+    private
+
+    def image_url_components
+      @image_url_components ||= small_image_url.match(%r{^(.+)_s(\.\w+(?:\?\d+)?)$}).to_a[1, 3]
+    end
+  end
+end

data/lib/pixiv/member.rb

@@ -0,0 +1,22 @@
+module Pixiv
+  class Member < Page
+    # Returns the URL for given +member_id+
+    # @param [Integer] member_id
+    # @return [String]
+    def self.url(member_id)
+      "#{ROOT_URL}/member.php?id=#{member_id}"
+    end
+
+    # @return [String]
+    lazy_attr_reader(:name) { at!('.profile_area h2').inner_text }
+    # @return [Integer]
+    lazy_attr_reader(:member_id) { at!('input[name="user_id"]').attr('value').to_i }
+    # return [Integer]
+    lazy_attr_reader(:pixiv_id) { at!('.profile_area img').attr('src').match(%r{/profile/([a-z_-]+)/}).to_a[1] }
+
+    alias id member_id
+
+    # @return [String]
+    def url; self.class.url(member_id) end
+  end
+end

data/lib/pixiv/page.rb

@@ -0,0 +1,91 @@
+module Pixiv
+  class Page
+    # A new Page
+    # @param [Hash{Symbol=>Object}] attrs
+    # @yieldreturn [Nokogiri::HTML::Document]
+    def self.lazy_new(attrs = {}, &doc_creator)
+      self.new(doc_creator, attrs)
+    end
+
+    # @overload initialize(doc, attrs = {})
+    #   @param [Nokogiri::HTTP::Document] doc
+    #   @param [Hash{Symbol=>Object}] attrs
+    # @overload initialize(doc_creator, attrs = {})
+    #   @param [#call] doc_creator
+    #   @param [Hash{Symbol=>Object}] attrs
+    def initialize(doc_or_doc_creator, attrs = {})
+      x = doc_or_doc_creator
+      if x.respond_to?(:call)
+        @doc_creator = x
+      else
+        @doc = x
+      end
+      set_attrs!(attrs)
+    end
+
+    # @return [Nokogiri::HTTP::Document]
+    def doc
+      @doc ||= begin
+                 doc = @doc_creator.call
+                 @doc_creator = nil
+                 doc
+               end
+    end
+
+    # Fetch +#doc+ and lazy attrs
+    # @return [self]
+    def force
+      doc
+      (@@lazy_attr_readers || []).each do |reader|
+        __send__(reader) if respond_to?(reader)
+      end
+      self
+    end
+
+    protected
+
+    # Defines lazy attribute reader
+    # @!macro attach lazy_attr_reader
+    #   @!attribute [r] $1
+    #   Lazily returns $1
+    def self.lazy_attr_reader(name, &reader)
+      ivar = :"@#{name.to_s.sub(/\?$/, '_q_')}"
+      (@@lazy_attr_readers ||= []) << ivar
+      define_method(name) do
+        if instance_variable_defined?(ivar)
+          instance_variable_get(ivar)
+        else
+          instance_variable_set(ivar, instance_eval(&reader))
+        end
+      end
+    end
+
+    # Set attribute values
+    #
+    # @param [Hash{Symbol=>Object}] attrs
+    #
+    # If +#set_attr!+ sets a value to an attribute,
+    # the lazy attr of the same name gets to return that value
+    # so its block will never called.
+    def set_attrs!(attrs)
+      attrs.each do |name, value|
+        ivar = :"@#{name.to_s.sub(/\?$/, '_q_')}"
+        instance_variable_set(ivar, value)
+      end
+    end
+
+    # +node.at(path)+ or raise error
+    # @param [String] path XPath or CSS path
+    # @return [Nokogiri::HTML::Node]
+    def at!(path, node = doc)
+      node.at(path) || Error::NodeNotFound.new("node for `#{path}` not found").raise
+    end
+
+    # +node.search(path) or raise error
+    # @param [String] path XPath or CSS path
+    # @return [Array<Nokogiri::HTML::Node>]
+    def search!(path, node = doc)
+      node.search(path) || Error::NodeNotFound.new("node for `#{path}` not found").raise
+    end
+  end
+end

data/lib/pixiv/page_collection.rb

@@ -0,0 +1,81 @@
+module Pixiv
+  module PageCollection
+    def first?
+      raise NotImplementError
+    end
+
+    def last?
+      raise NotImplementError
+    end
+
+    def next_url
+      raise NotImplementError
+    end
+
+    def prev_url
+      raise NotImplementError
+    end
+
+    def page_class
+      raise NotImplementError
+    end
+
+    def page_urls
+      raise NotImplementError
+    end
+
+    def page_hash
+      page_urls.map {|url| {url: url} }
+    end
+  end
+
+  class PageCollection::Enumerator
+    include Enumerable
+
+    def initialize(client, collection)
+      @client = client
+      @collection = collection
+    end
+
+    def each_page
+      each_collection do |collection|
+        pages_from_collection(collection).each do |page|
+          yield page
+        end
+      end
+    end
+
+    alias each each_page
+
+    def each_slice(n = nil)
+      if n
+        super
+      else
+        if block_given?
+          each_collection do |collection|
+            yield pages_from_collection(collection)
+          end
+        else
+          ::Enumerator.new {|y| each_slice {|slice| y << slice } }
+        end
+      end
+    end
+
+    private
+
+    def pages_from_collection(collection)
+      collection.page_hashes.map {|attrs|
+        url = attrs.delete(:url)
+        collection.page_class.lazy_new(attrs) { @client.agent.get(url) }
+      }
+    end
+
+    def each_collection(collection = @collection)
+      loop do
+        yield collection
+        break unless collection.next_url
+        collection = collection.class.new(@client.agent.get(collection.next_url))
+      end
+    end
+  end
+end

data/lib/pixiv/version.rb

@@ -0,0 +1,3 @@
+module Pixiv
+  VERSION = "0.0.1"
+end

data/pixiv.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pixiv/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pixiv"
+  gem.version       = Pixiv::VERSION
+  gem.authors       = ["Tomoki Aonuma"]
+  gem.email         = ["uasi@uasi.jp"]
+  gem.description   = %q{A client library for Pixiv}
+  gem.summary       = %q{A client library for Pixiv}
+  gem.homepage      = "https://github.com/uasi/pixiv"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'mechanize', '~> 2.0'
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: pixiv
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tomoki Aonuma
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A client library for Pixiv
+email:
+- uasi@uasi.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pixiv.rb
+- lib/pixiv/bookmark_list.rb
+- lib/pixiv/client.rb
+- lib/pixiv/error.rb
+- lib/pixiv/illust.rb
+- lib/pixiv/member.rb
+- lib/pixiv/page.rb
+- lib/pixiv/page_collection.rb
+- lib/pixiv/version.rb
+- pixiv.gemspec
+homepage: https://github.com/uasi/pixiv
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A client library for Pixiv
+test_files: []
+has_rdoc: