kat 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6431728ef307439d3dff0b3f60e3619c0ae4d37c
-  data.tar.gz: 914cef06e731347f85c4c8ba9c5363711d134e4a
+  metadata.gz: a6ad7f5809e7cfbdc5379f566d93c61a361a51e6
+  data.tar.gz: 852186a99d1af3374c4de52f0bb91c45d3c3a5bc
 SHA512:
-  metadata.gz: d64ef6998d9d27411680c8aa08e42d6cf5d15dbe33a82122a9ede9ba04c75841e24a93b98c126207beadd3713e4d7102c67ccbd5fdd0411b716011050ed33030
-  data.tar.gz: 7ec114ce7cf00ca98b9d94345c8cc1b6dbaf3aaf812334146fe58ae7e84f224cb92ec677c3e948d4593939e17d4058d3c4c11b967a75317fac8baa133668aa56
+  metadata.gz: cd2896742673ed05ccec2bd1ec63b2af9498911683a9b21e8ad0a7352d8311a2532f7ef8a26960266e4514d9a5aae979762acd710fde36b252159c74cb41d301
+  data.tar.gz: fc2812d838cc89f103fa9a52e6f2a3ae1345f466d9a732539eb1d26bc6adfa0971ff76961cd7296606aff6b83af9d8fa47639f34b66b2cb17a21905a9477b1a2

data/bin/kat

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+e = []
+
+require 'open-uri'
+%w(kat trollop highline).sort.each do |lib|
+  begin
+    require lib
+  rescue LoadError
+    e << lib.sub(/_/, '')
+  end
+end
+
+unless e.empty?
+  puts <<-EOS
+Kickass Torrents Search relies on #{e.join(', ').sub(/^(.*), /, '\1 and ')}. To download the gem#{'s' if e.size > 1} type:
+
+  gem install #{e.join ' '}
+
+EOS
+  exit
+end
+
+VERSION_STR = "#{Kat::NAME} #{Kat::VERSION} (c) 2013 #{Kat::AUTHOR}"
+
+list_args = { :categories => :category, :times      => :added,
+              :languages  => :language, :platforms  => :platform }
+
+options = Trollop::options do
+  version VERSION_STR
+  banner <<-EOS
+#{VERSION_STR}
+
+Usage: #{File.basename __FILE__} [options] <query>+
+
+  Options:
+EOS
+
+  opt :exact,      'Exact phrase',              :type => :string
+  opt :or,         'Optional words',            :type => :string, :multi => true
+  opt :without,    'Without this word',         :type => :string, :multi => true
+
+  opt :sort,       'Sort field (size, files, time_add, seeders, leechers)', :type => :string
+  opt :asc,        'Ascending sort order (descending is default)', :type => :boolean
+
+  opt :added,      'Age of the torrent',        :type => :string, :short => :a
+  opt :category,   'Category',                  :type => :string, :short => :c
+  opt :files,      'Number of files',           :type => :int
+  opt :imdb,       'IMDB ID',                   :type => :int
+  opt :seeds,      'Minimum number of seeders', :type => :int, :short => :s
+  opt :user,       'Uploader',                  :type => :string
+  opt :season,     'Television season',         :type => :int
+  opt :episode,    'Television episode',        :type => :int, :short => :e
+
+  opt :language,   'Language',                  :type => :int
+  opt :platform,   'Game platform',             :type => :int
+
+  opt :safe,       'Family safety filter',      :type => :boolean
+  opt :verified,   'Verified',                  :type => :boolean, :short => :m
+
+  opt :output,     'Directory to save torrents in', :type => :string, :short => :o
+
+  list_args.each {|k, v| opt k, "List the #{k} that may be used with --#{v}", :type => :boolean }
+end
+
+unless list_args.select! {|k, v| options[k] }.empty?
+  puts VERSION_STR
+  list_args.each do |opt, label|
+    args = Kat.send opt
+    puts "\n  #{label.to_s.capitalize}"
+    puts unless args.values.first.is_a? Array
+    args.each {|k, v| puts v.is_a?(Array) ? "\n  %12s => #{v.join "\n\t\t  "}" % k : "  %-23s => #{v}" % k }
+    puts
+  end
+else
+  k = Kat.new ARGV.join(' '), options
+  h = HighLine.new
+  page = 0
+  puts VERSION_STR
+
+  loop do
+    r = k.search page
+    if r.nil?
+      puts "\nNo results"
+      break
+    end
+
+    n = page < k.pages - 1
+    p = page > 0
+
+    puts "\n%-72s S     L\n\n" % "Page #{page + 1} of #{k.pages}"
+    r.each_with_index do |t, i|
+      puts "%2d. %-64s %5d %5d" % [ i + 1, t[:title][0..63], t[:seeds], t[:leeches] ]
+    end
+
+    commands = "[#{'n' if n}#{'p' if p}q]|"
+    _01to09  = "[1#{r.size >  9 ? '-9' : '-' + r.size.to_s}]"
+    _10to19  = "#{r.size   >  9 ? '|1[0-' + (r.size > 19 ? '9' : (r.size - 10).to_s) + ']' : ''}"
+    _20to25  = "#{r.size   > 19 ? '|2[0-' + (r.size - 20).to_s + ']' : ''}"
+    prompt   = "\n1#{r.size > 1 ? '-' + r.size.to_s : ''} to download" +
+               "#{', (n)ext' if n}" +
+               "#{', (p)rev' if p}" +
+               ', (q)uit: '
+
+    case (answer = h.ask(prompt) {|q| q.validate = /^(#{commands}#{_01to09}#{_10to19}#{_20to25})$/ })
+    when 'q' then break
+    when 'n' then page += 1 if n
+    when 'p' then page -= 1 if p
+    else
+      if (1..r.size).include? answer.to_i
+        torrent = k.results[page][answer.to_i - 1]
+        puts "\nDownloading: #{torrent[:title]}"
+
+        begin
+          uri = URI torrent[:download]
+          uri.query = nil
+          response = uri.read
+          file = "#{File.expand_path(options[:output] || '.')}/#{torrent[:title].gsub(/ /, '.').gsub(/[^a-z0-9()_.-]/i, '')}.torrent"
+          File.open(file, 'w') {|f| f.write response }
+        rescue => e
+          puts e.message
+        end
+      end
+    end
+  end
+  puts
+end

data/kat.gemspec

@@ -6,14 +6,12 @@ require 'kat/version'
 Gem::Specification.new do |s|
   s.name          = 'kat'
   s.version       = Kat::VERSION
-  s.date          = '2013-08-09'
+  s.date          = Time.new.strftime '%Y-%m-%d'
   s.author        = 'Fission Xuiptz'
   s.email         = 'fissionxuiptz@softwaremojo.com'
   s.homepage      = 'http://github.com/fissionxuiptz/kat'
   s.license       = 'MIT'
 
-  s.rubyforge_project = 'kat'
-
   s.summary       = 'Kickass Torrents Interface'
   s.description   = 'A Ruby interface to Kickass Torrents'
 
@@ -22,5 +20,7 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = [ 'lib' ]
 
-  s.add_runtime_dependency 'nokogiri'
+  s.add_runtime_dependency 'nokogiri', '~> 1.6'
+  s.add_runtime_dependency 'highline', '~> 1.6'
+  s.add_runtime_dependency 'trollop', '~> 2.0'
 end

data/lib/kat.rb

@@ -1,22 +1,24 @@
-# TODO: Lookup advanced search for language and platform values
-
 require 'nokogiri'
 require 'open-uri'
+require 'kat/version'
 
 class Kat
   KAT_URL = 'http://kickass.to'
-  EMPTY_URL = "new"
-  SEARCH_URL = "usearch"
+  EMPTY_URL = 'new'
+  SEARCH_URL = 'usearch'
   ADVANCED_URL = "#{KAT_URL}/torrents/search/advanced/"
 
-  STRING_FIELDS = [ :category, :seeds, :user, :age, :files, :imdb, :season, :episode ]
-
-  # The names of these fields are transposed for ease of use
-  SELECT_FIELDS = [ { :name => :language, :id => :lang_id }, { :name => :platform, :id => :platform_id } ]
+  STRING_FIELDS = [ :seeds, :user, :files, :imdb, :season, :episode ]
 
   # If these are set to anything but nil or false, they're turned on in the query
   SWITCH_FIELDS = [ :safe, :verified ]
 
+  # The names of these fields are transposed for ease of use
+  SELECT_FIELDS = [ { :name => :categories, :label => :category, :id => :category },
+                    { :name => :times,      :label => :added,    :id => :age },
+                    { :name => :languages,  :label => :language, :id => :lang_id },
+                    { :name => :platforms,  :label => :platform, :id => :platform_id } ]
+
   SORT_FIELDS   = %w(size files_count time_add seeders leechers)
 
   # The number of pages of results
@@ -25,21 +27,23 @@ class Kat
   # Any error in searching is stored here
   attr_reader :error
 
+  @@doc = nil
+
   #
   # Create a new +Kat+ object to search Kickass Torrents.
-  #
-  # The search term can be nil, a string/symbol, or an array of strings/symbols.
-  #
-  # Valid options are in STRING_FIELDS, SELECT_FIELDS or SWITCH_FIELDS
+  # The search_term can be nil, a string/symbol, or an array of strings/symbols.
+  # Valid options are in STRING_FIELDS, SELECT_FIELDS or SWITCH_FIELDS.
   #
   def initialize search_term = nil, opts = {}
     @search_term = []
-    @options = opts.is_a?(Hash) ? opts : {}
-    self.query = search_term.is_a?(Array) ? search_term.dup : search_term
+    @options = {}
+
+    self.query = search_term
+    self.options = opts
   end
 
   #
-  # Use Kat.search(search_term) to do a quick search
+  # Kat.search will do a quick search and return the results
   #
   def self.search search_term
     self.new(search_term).search
@@ -48,21 +52,20 @@ class Kat
   #
   # Generate a query string from the stored options, supplying an optional page number
   #
-  def query page = 0
-    q = [ SEARCH_URL, @query.join(' ').gsub(/[^a-z0-9: _-]/i, '') ]
-    q = [ EMPTY_URL ] if q[1].empty?
-    q << page + 1 if page > 0
-    q << if SORT_FIELDS.include? @options[:sort].to_s
+  def query_str page = 0
+    str = [ SEARCH_URL, @query.join(' ').gsub(/[^a-z0-9: _-]/i, '') ]
+    str = [ EMPTY_URL ] if str[1].empty?
+    str << page + 1 if page > 0
+    str << if SORT_FIELDS.include? @options[:sort].to_s
       "?field=#{options[:sort].to_s}&sorder=#{options[:asc] ? 'asc' : 'desc'}"
     else
       ''    # ensure a trailing slash after the search terms or page number
     end
-    q.join '/'
+    str.join '/'
   end
 
   #
-  # Change the search term for the query, triggering a rebuild of the query string
-  # and clearing past results.
+  # Change the search term, triggering a query rebuild and clearing past results.
   #
   # Raises ArgumentError if search_term is not a String, Symbol or Array
   #
@@ -84,7 +87,7 @@ class Kat
   end
 
   #
-  # Change search options with a hash, triggering a rebuild of the query string and
+  # Change search options with a hash, triggering a query string rebuild and
   # clearing past results.
   #
   # Raises ArgumentError if opts is not a Hash
@@ -101,9 +104,9 @@ class Kat
   # cache results for subsequent calls of search with the same query string.
   #
   def search page = 0
-    unless query.empty? or @results[page] or (@pages > -1 and page >= @pages)
+    unless @results[page] or (@pages > -1 and page >= @pages)
       begin
-        doc = Nokogiri::HTML(open("#{KAT_URL}/#{URI::encode(query page)}"))
+        doc = Nokogiri::HTML(open("#{KAT_URL}/#{URI::encode(query_str page)}"))
         @results[page] = doc.css('td.torrentnameCell').map do |node|
           { :title    => node.css('a.normalgrey').text,
             :magnet   => node.css('a.imagnet').first.attributes['href'].value,
@@ -128,13 +131,21 @@ class Kat
       rescue => e
         # No result throws a 404 error.
         @pages = 0 if e.class == OpenURI::HTTPError and e.message['404 Not Found']
-        @error = { :error => e, :query => query(page) }
+        @error = { :error => e, :query => query_str(page) }
       end
     end
 
     results[page]
   end
 
+  #
+  # For message chaining
+  #
+  def do_search page = 0
+    search page
+    self
+  end
+
   #
   # Get a copy of the results
   #
@@ -143,7 +154,14 @@ class Kat
   end
 
   #
-  # If the method_sym or its plural is a field name in the results list, this will tell us
+  # If method_sym is a field name in SELECT_FIELDS, we can fetch the list of values.
+  #
+  def self.respond_to? method_sym, include_private = false
+    SELECT_FIELDS.find {|field| field[:name] == method_sym } ? true : super
+  end
+
+  #
+  # If method_sym or its plural is a field name in the results list, this will tell us
   # if we can fetch the list of values. It'll only happen after a successful search.
   #
   def respond_to? method_sym, include_private = false
@@ -170,20 +188,58 @@ private
     @query += @options[:without].map {|s| "-#{s}" } if @options[:without]
 
     STRING_FIELDS.each {|f| @query << "#{f}:#{@options[f]}" if @options[f] }
-    SELECT_FIELDS.each {|f| @query << "#{f[:id]}:#{@options[f[:name]]}" if @options[f[:name]].to_i > 0 }
     SWITCH_FIELDS.each {|f| @query << "#{f}:1" if @options[f] }
+    SELECT_FIELDS.each do |f|
+      if (@options[f[:label]].to_s.to_i > 0 and f[:id].to_s['_id']) or
+         (@options[f[:label]] and not f[:id].to_s['_id'])
+        @query << "#{f[:id]}:#{@options[f[:label]]}"
+      end
+    end
+  end
+
+  #
+  # Get a list of options for a particular selection field from the advanced search form
+  #
+  # Raises an error unless the label is in SELECT_FIELDS
+  #
+  def self.field_options label
+    begin
+      raise 'Unknown search field' unless SELECT_FIELDS.find {|f| f[:label] == label.to_sym }
+
+      opts = (@@doc ||= Nokogiri::HTML(open(ADVANCED_URL))).css('table.formtable td').find do |e|
+        e.text[/#{label.to_s}/i]
+      end.next_element.first_element_child.children
+
+      unless (group = opts.css('optgroup')).empty?
+        # Categories
+        group.inject({}) {|c, og| c[og.attributes['label'].value] = og.children.map {|o| o.attributes['value'].value }; c }
+      else
+        # Times, languages, platforms
+        opts.reject {|o| o.attributes.empty? }.inject({}) {|p, o| p[o.text] = o.attributes['value'].value; p }
+      end
+    rescue => e
+      { :error => e }
+    end
+  end
+
+  #
+  # If method_sym is a field name in SELECT_FIELDS, fetch the list of values.
+  #
+  def self.method_missing method_sym, *args, &block
+    if respond_to? method_sym
+      return self.field_options SELECT_FIELDS.find {|field| field[:name] == method_sym }[:label]
+    end
+    super
   end
 
   #
   # If method_sym or its plural form is a field name in the results list, fetch the list of values.
   # Can only happen after a successful search.
   #
-  def method_missing method_sym, *arguments, &block
-    # Don't need no fancy schmancy pluralizing method. Just try chopping off the 's'.
-    m = method_sym.to_s.chop.to_sym
-    if not (@results.empty? or @results.last.empty?) and
-           (@results.last.first[method_sym] or @results.last.first[m])
-      return @results.compact.map {|rs| rs.map {|r| r[method_sym] || r[m] } }.flatten
+  def method_missing method_sym, *args, &block
+    if respond_to? method_sym
+      # Don't need no fancy schmancy singularizing method. Just try chopping off the 's'.
+      return @results.compact.map {|rs| rs.map {|r| r[method_sym] || r[method_sym.to_s.chop.to_sym] } }.flatten
     end
     super
   end

data/lib/kat/version.rb

@@ -1,3 +1,5 @@
 class Kat
-  VERSION = '0.3.0'
+  NAME = 'Kickass Torrents Search'
+  VERSION = '1.0.0'
+  AUTHOR = 'Fission Xuiptz'
 end

data/test/kat_test.rb

@@ -1,256 +1,122 @@
 require 'minitest/autorun'
-
-begin
-  require 'minitest/pride'
-rescue LoadError
-end
-
 require 'kat'
 
+blue_peter = Kat.new
+blue_peter.do_search.do_search 1
+
 describe Kat do
-  before do
-    @kat = { :vanilla  => Kat.new,
-             :basic    => Kat.new('test'),
-             :advanced => Kat.new('test', { :category => 'books' }) }
-  end
 
-# Quick search tests
+  let(:kat) { Kat.new 'test' }
+  let(:kat_opts) { Kat.new 'test', { :category => 'books' } }
 
-  describe 'when quick searching' do
-    it 'returns a result set' do
-      Kat.search('test').must_be_instance_of Array
+  describe 'basic search' do
+    it 'returns a full result set' do
       Kat.search('test').size.must_equal 25
     end
   end
 
-# Vanilla query tests
-
-  describe 'when checking if a vanilla query responds to result field before searching' do
-    it 'returns false' do
-      [ :titles, :magnets, :downloads, :sizes, :files, :ages, :seeds, :leeches ].each do |s|
-        @kat[:vanilla].respond_to?(s).must_equal false
-      end
-    end
-  end
-
-  describe 'when checking if a vanilla query responds to result fields after searching' do
-    it 'returns true' do
-      @kat[:vanilla].search
-      [ :titles, :magnets, :downloads, :sizes, :files, :ages, :seeds, :leeches ].each do |s|
-        @kat[:vanilla].respond_to?(s).must_equal true
-      end
+  describe 'advanced search' do
+    it 'returns a valid query string' do
+      blue_peter.query_str.must_equal 'new/'
+      blue_peter.query_str(1).must_equal 'new/2/'
+      kat.query_str.must_equal 'usearch/test/'
+      kat_opts.query_str(1).must_equal 'usearch/test category:books/2/'
+      kat_opts.query = :foobar
+      kat_opts.query_str(1).must_equal 'usearch/foobar category:books/2/'
+      kat_opts.query = [ 0, {}, [ :test, 0..1, [ 'user:foo' ] ] ]
+      kat_opts.query_str(1).must_equal 'usearch/test user:foo category:books/2/'
     end
-  end
 
-  describe 'when building a vanilla query' do
-    it 'returns a query to new torrents' do
-      @kat[:vanilla].query.must_equal 'new/'
+    it 'returns a valid query string based on many options' do
+      kat_opts.options = { :files => 2, :safe => true, :language => 2, :sort => :files_count, :asc => true, :seeds => 2 }
+      kat_opts.query_str(1).must_equal 'usearch/test seeds:2 files:2 safe:1 category:books lang_id:2/2/?field=files_count&sorder=asc'
     end
-  end
 
-  describe 'when searching with a vanilla query' do
-    it 'returns a full result set' do
-      @kat[:vanilla].search.must_be_instance_of Array
-      [ :search, :titles, :magnets, :downloads, :sizes, :files, :ages, :seeds, :leeches ].each do |s|
-        @kat[:vanilla].send(s).size.must_equal 25
+    it 'wont respond to result fields before a search' do
+      [ :titles, :files ].each do |s|
+        kat.respond_to?(s).must_equal false
       end
     end
-  end
 
-  describe 'when searching the 2nd page of a vanilla query' do
-    it 'returns a full result set' do
-      @kat[:vanilla].search(1).must_be_instance_of Array
-      @kat[:vanilla].search(1).size.must_equal 25
-    end
-  end
-
-  describe 'when searching 2 pages of a vanilla query' do
-    it 'returns 50 results for each result field' do
-      @kat[:vanilla].search
-      @kat[:vanilla].search(1)
-      if @kat[:vanilla].respond_to? :titles
-        [ :titles, :magnets, :downloads, :sizes, :files, :ages, :seeds, :leeches ].each do |s|
-          @kat[:vanilla].send(s).size.must_equal 50
-        end
-      else
-        # Returning a failure, not an error
-        proc { @kat[:vanilla].titles }.wont_raise NoMethodError
+    it 'responds to result fields after a search' do
+      [ :titles, :files ].each do |s|
+        blue_peter.respond_to?(s).must_equal true
       end
     end
-  end
 
-  describe 'when rebuilding a vanilla query' do
-    it 'returns a query to new torrents' do
-      @kat[:vanilla].query = nil
-      @kat[:vanilla].query.must_equal 'new/'
+    it 'returns identical result sets' do
+      blue_peter.results[0].must_equal blue_peter.search
     end
-  end
 
-  describe 'when changing the search term on a vanilla query' do
-    it 'returns a query to usearch' do
-      @kat[:vanilla].query = 'test'
-      @kat[:vanilla].query.must_equal 'usearch/test/'
-    end
-  end
-
-  describe 'when adding an array of search terms to a vanilla query' do
-    it 'returns a query to usearch' do
-      @kat[:vanilla].query = [ 'test', 'category:books' ]
-      @kat[:vanilla].query.must_equal 'usearch/test category:books/'
-    end
-  end
-
-  describe 'when adding an array of crap to a vanilla query' do
-    it 'returns a valid query' do
-      @kat[:vanilla].query = [ 0, {}, [ 'test', 0..1 ] ]
-      @kat[:vanilla].query.must_equal 'usearch/test/'
-    end
-  end
-
-# Basic query tests
-
-  describe 'when checking if a basic query responds to result fields after searching' do
-    it 'returns true' do
-      @kat[:basic].search
-      [ :titles, :magnets, :downloads, :sizes, :files, :ages, :seeds, :leeches ].each do |s|
-        @kat[:basic].respond_to?(s).must_equal true
-      end
-    end
-  end
-
-  describe 'when building a basic query' do
-    it 'returns a query to usearch' do
-      @kat[:basic].query.must_equal 'usearch/test/'
-    end
-  end
-
-  describe 'when building a basic query with pages' do
-    it 'returns a query to usearch with page numbers' do
-      @kat[:basic].query(1).must_equal 'usearch/test/2/'
-    end
-  end
-
-  describe 'when changing the search term of a basic query to nil' do
-    it 'returns a query to new' do
-      @kat[:basic].query = nil
-      @kat[:basic].query.must_equal 'new/'
-    end
-  end
-
-  describe 'when adding options to a basic query' do
-    it 'returns a query to usearch with options' do
-      @kat[:basic].options = { :category => 'movies' }
-      @kat[:basic].options.must_equal({ :category => 'movies' })
-      @kat[:basic].query.must_equal 'usearch/test category:movies/'
-      @kat[:basic].results.must_be_empty
-      @kat[:basic].pages.must_be :==, -1
-    end
-  end
-
-  describe 'when adding options to a basic query with pages' do
-    it 'returns a query to usearch with options and page numbers' do
-      @kat[:basic].options = { :category => 'movies' }
-      @kat[:basic].options.must_equal({ :category => 'movies' })
-      @kat[:basic].query(1).must_equal 'usearch/test category:movies/2/'
-      @kat[:basic].results.must_be_empty
-      @kat[:basic].pages.must_be :==, -1
-    end
-  end
-
-  describe 'when searching with a basic query' do
-    it 'returns a result set' do
-      @kat[:basic].search.must_be_instance_of Array
-      @kat[:basic].search.size.must_equal 25
-      @kat[:basic].pages.must_be :>, 0
-    end
-  end
-
-  describe 'when searching the 2nd page of a basic query' do
-    it 'returns a result set' do
-      @kat[:basic].search(1).must_be_instance_of Array
-      @kat[:basic].search(1).size.must_equal 25
-      @kat[:basic].pages.must_be :>, 0
+    it 'returns a full result set' do
+      blue_peter.search(1).size.must_equal 25
+      blue_peter.titles.size.must_equal 50
     end
-  end
 
-  describe 'when searching with the same basic query twice' do
-    it 'returns the same result set' do
-      @kat[:basic].search.must_equal @kat[:basic].search
+    it 'returns a valid query string with options' do
+      bp = blue_peter.dup
+      bp.options = { :user => :foobar }
+      bp.options.must_equal({ :user => :foobar })
+      bp.query_str(1).must_equal 'usearch/user:foobar/2/'
+      bp.results.must_be_empty
+      bp.pages.must_equal(-1)
     end
-  end
 
-  describe 'when searching for something that does not exist in a basic query' do
-    it 'returns an empty set, sets an error and sets pages to 0' do
-      @kat[:basic].query = 'owijefbvoweivf'
-      @kat[:basic].search.must_be_nil
-      @kat[:basic].error.must_be_instance_of Hash
-      @kat[:basic].error[:error].must_be_instance_of OpenURI::HTTPError
-      @kat[:basic].error[:error].message.must_equal '404 Not Found'
-      @kat[:basic].pages.must_equal 0
+    it 'can raise an ArgumentError for query=' do
+      proc { kat.query = 0 }.must_raise ArgumentError
     end
-  end
 
-  describe 'when searching for something with 1 page of results in a basic query' do
-    it 'returns a result set and sets the pages to 1' do
-      @kat[:basic].options = { :category => 'wallpapers' }
-      @kat[:basic].options.must_equal({ :category => 'wallpapers' })
-      @kat[:basic].search.wont_be_nil
-      @kat[:basic].search.size.wont_equal 0
+    it 'can raise an ArgumentError for options=' do
+      proc { kat.options = 'foobar' }.must_raise ArgumentError
     end
-  end
 
-  describe 'when passing query= a Symbol' do
-    it 'works just like a String' do
-      @kat[:basic].query = :test
-      @kat[:basic].query.must_equal 'usearch/test/'
+    it 'works when there are fewer than 25 results' do
+      kat.options = { :category => :wallpapers }
+      kat.search.wont_be_nil
+      kat.search.size.wont_equal 0
+      kat.pages.must_equal 1
     end
-  end
 
-  describe 'when passing a non-String-or-Array object to query=' do
-    it 'raises an ArgumentError' do
-      proc { @kat[:basic].query = { :foo => 'bar' } }.must_raise ArgumentError
+    it 'can return 0 results, set an error and set pages to 0' do
+      kat.query = 'owijefbvoweivf'
+      kat.search.must_be_nil
+      kat.error[:error].must_be_instance_of OpenURI::HTTPError
+      kat.error[:error].message.must_equal '404 Not Found'
+      kat.pages.must_equal 0
     end
   end
 
-  describe 'when passing a non-Hash object to options=' do
-    it 'raises an ArgumentError' do
-      proc { @kat[:basic].options = 'foobar' }.must_raise ArgumentError
+  describe 'field options' do
+    it 'returns a list of time added options' do
+      times = Kat.times
+      times.must_be_instance_of Hash
+      times.wont_be_empty
+      times[:error].must_be_nil
     end
-  end
 
-# Advanced query tests
-
-  describe 'when building an advanced query' do
-    it 'returns a query with options to usearch' do
-      @kat[:advanced].query.must_equal 'usearch/test category:books/'
-    end
-  end
-
-  describe 'when building an advanced query with pages' do
-    it 'returns a query with options and page numbers' do
-      @kat[:advanced].query(1).must_equal 'usearch/test category:books/2/'
+    it 'returns a list of categories' do
+      categories = Kat.categories
+      categories.must_be_instance_of Hash
+      categories.wont_be_empty
+      categories[:error].must_be_nil
     end
-  end
 
-  describe 'when building an advanced query with select fields' do
-    it 'returns a query with options to usearch' do
-      @kat[:advanced].options = { :language => 2 }
-      @kat[:advanced].query.must_equal 'usearch/test category:books lang_id:2/'
+    it 'returns a list of languages' do
+      languages = Kat.languages
+      languages.must_be_instance_of Hash
+      languages.wont_be_empty
+      languages[:error].must_be_nil
     end
-  end
 
-  describe 'when using symbols instead of strings in an advanced query' do
-    it 'returns the same query string' do
-      @kat[:advanced].options = { :category => :books }
-      @kat[:advanced].query.must_equal 'usearch/test category:books/'
+    it 'returns a list of platforms' do
+      platforms = Kat.platforms
+      platforms.must_be_instance_of Hash
+      platforms.wont_be_empty
+      platforms[:error].must_be_nil
     end
-  end
 
-  describe 'when sorting fields' do
-    it 'adds a sort part to the query string' do
-      @kat[:advanced].options = { :sort => :size }
-      @kat[:advanced].query.must_equal 'usearch/test category:books/?field=size&sorder=desc'
+    it 'returns an error' do
+      Kat.field_options(:foobar)[:error].must_be_instance_of RuntimeError
     end
   end
-
 end

metadata

@@ -1,32 +1,61 @@
 --- !ruby/object:Gem::Specification
 name: kat
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Fission Xuiptz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-09 00:00:00.000000000 Z
+date: 2013-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
 description: A Ruby interface to Kickass Torrents
 email: fissionxuiptz@softwaremojo.com
-executables: []
+executables:
+- kat
 extensions: []
 extra_rdoc_files: []
 files:
@@ -36,6 +65,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/kat
 - kat.gemspec
 - lib/kat.rb
 - lib/kat/version.rb
@@ -59,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: kat
+rubyforge_project: 
 rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4