kat 1.0.0 → 2.0.0

data/test/kat/test_colour.rb

@@ -0,0 +1,136 @@
+require 'minitest/autorun'
+require File.dirname(__FILE__) + '/../../lib/kat/colour'
+
+describe Kat::Colour do
+  let(:colours) { %i(black red green yellow blue magenta cyan white) }
+
+  describe 'colour' do
+    it 'has working flag methods' do
+      Kat::Colour.capable?.must_equal true
+      Kat::Colour.colour = false
+      Kat::Colour.colour?.must_equal false
+      Kat::Colour.colour = true
+      Kat::Colour.colour?.must_equal true
+    end
+
+    it 'has colour methods' do
+      colours.each { |c|
+        ''.respond_to?(c).must_equal true
+        :s.respond_to?(c).must_equal true
+        [].respond_to?(c).must_equal true
+        {}.respond_to?(c).wont_equal true
+      }
+    end
+
+    it 'colours strings' do
+      colours.each_with_index { |c, i|
+        str = 'foobar'
+        result = "\e[0;#{ 30 + i }mfoobar\e[0m"
+        intense_result = "\e[1;#{ 30 + i }mfoobar\e[0m"
+
+        str.send(c).must_equal result
+        str.must_equal 'foobar'
+
+        str.send(c, true).must_equal intense_result
+        str.must_equal 'foobar'
+
+        str.send("#{ c }!").must_equal result
+        str.must_equal result
+
+        str = 'foobar'
+        str.send("#{ c }!", true).must_equal intense_result
+        str.must_equal intense_result
+      }
+    end
+
+    it 'uncolour strings' do
+      str = "\e[0;30mfoobar\e[0m"
+      result = str.dup
+
+      str.uncolour.must_equal 'foobar'
+      str.must_equal result
+
+      str.uncolour!.must_equal 'foobar'
+      str.must_equal 'foobar'
+    end
+
+    it 'colours symbols' do
+      colours.each_with_index { |c, i|
+        sym = :foobar
+        result = "\e[0;#{ 30 + i }mfoobar\e[0m"
+        intense_result = "\e[1;#{ 30 + i }mfoobar\e[0m"
+
+        sym.send(c).must_equal result
+        sym.must_equal :foobar
+
+        sym.send(c, true).must_equal intense_result
+        sym.must_equal :foobar
+
+        sym.send("#{ c }!").must_equal :foobar
+        sym.must_equal :foobar
+
+        sym.send("#{ c }!", true).must_equal :foobar
+        sym.must_equal :foobar
+      }
+    end
+
+    it 'does not uncolour symbols' do
+      sym = :foobar
+
+      sym.uncolour.must_equal :foobar
+      sym.must_equal :foobar
+
+      sym.uncolour!.must_equal :foobar
+      sym.must_equal :foobar
+    end
+
+    it 'colours arrays of strings and symbols' do
+      colours.each_with_index { |c, i|
+        s = ['foobar', :foobar, nil, ['foobar', :foobar, nil]]
+        t = ['foobar', :foobar, nil, ['foobar', :foobar, nil]]
+        result = [
+          "\e[0;#{ 30 + i }mfoobar\e[0m",
+          "\e[0;#{ 30 + i }mfoobar\e[0m",
+          nil,
+          ["\e[0;#{ 30 + i }mfoobar\e[0m",
+           "\e[0;#{ 30 + i }mfoobar\e[0m",
+           nil]
+        ]
+
+        s.send(c).must_equal result
+        s.must_equal t
+
+        result[1] = :foobar
+        result[3][1] = :foobar
+        s.send("#{ c }!").must_equal result
+        s.must_equal result
+      }
+    end
+
+    it 'uncolours arrays of strings' do
+      s = [
+        "\e[0;30mfoobar\e[0m",
+        :foobar,
+        nil,
+        ["\e[0;30mfoobar\e[0m",
+         :foobar,
+         nil]
+      ]
+      t = [
+        "\e[0;30mfoobar\e[0m",
+        :foobar,
+        nil,
+        ["\e[0;30mfoobar\e[0m",
+         :foobar,
+         nil]
+      ]
+      result = ['foobar', :foobar, nil, ['foobar', :foobar, nil]]
+
+      s.uncolour.must_equal result
+      s.must_equal t
+
+      s.uncolour!.must_equal result
+      s.must_equal result
+    end
+  end
+end

data/test/kat/test_field_map.rb

@@ -0,0 +1,46 @@
+require 'minitest/autorun'
+require File.dirname(__FILE__) + '/../../lib/kat/field_map'
+
+describe Kat do
+  describe 'field map' do
+    let(:f) { Kat::FIELD_MAP }
+
+    it 'is a hash' do
+      f.must_be_instance_of Hash
+    end
+
+    it 'has symbolised keys' do
+      f.keys.wont_be_empty
+      f.keys.each { |key|
+        key.must_be_instance_of Symbol
+      }
+    end
+
+    it 'has a hash for values' do
+      f.values.wont_be_empty
+      f.values.each { |value|
+        value.must_be_instance_of Hash
+      }
+    end
+
+    it 'has symbolised keys in each value' do
+      f.values.each { |value|
+        value.keys.wont_be_empty
+        value.keys.each { |key|
+          key.must_be_instance_of Symbol
+          case key
+          when :desc
+            value[key].must_be_instance_of String
+          when :multi, :check, :input
+            value[key].must_equal true
+          when :short
+            value[key].must_be_instance_of Symbol
+            value[key].must_match /\A([a-z]|none)\Z/
+          else
+            value[key].must_be_instance_of Symbol
+          end
+        }
+      }
+    end
+  end
+end

data/test/kat/test_options.rb

@@ -0,0 +1,77 @@
+require 'minitest/autorun'
+require File.dirname(__FILE__) + '/../../lib/kat/options'
+
+describe Kat::Options do
+
+  describe 'options map' do
+    let(:opts) { Kat::Options.options_map }
+
+    it 'is a hash' do
+      opts.must_be_instance_of Hash
+      opts.keys.wont_be_empty
+      opts.values.wont_be_empty
+    end
+
+    it 'has symbolised keys' do
+      opts.keys.each { |key|
+        key.must_be_instance_of Symbol
+        key.wont_equal :size
+      }
+    end
+
+    it 'has a hash for values, each with a description' do
+      opts.values.each { |value|
+        value.must_be_instance_of Hash
+        value.keys.must_include :desc
+      }
+    end
+
+    it 'has symbolised keys in each value' do
+      opts.each { |key, value|
+        value.each { |k, v|
+          k.must_be_instance_of Symbol
+          case k
+          when :desc
+            v.must_be_instance_of String
+          when :multi
+            v.must_equal true
+          when :short
+            v.must_be_instance_of Symbol
+            v.must_match /\A([a-z]|none)\Z/
+          else
+            v.must_be_instance_of Symbol
+          end
+        }
+      }
+    end
+  end
+
+  describe 'parse options' do
+    it 'returns an options hash with everything off' do
+      args = ['foobar']
+      opts = Kat::Options.parse args
+
+      args.must_equal ['foobar']
+
+      opts.must_be_instance_of Hash
+      opts.wont_be_empty
+      opts.values.each { |value|
+        [[], nil, false].must_include value
+      }
+    end
+
+    it 'returns an options hash with some options switched on' do
+      args = %w(foobar --or baz --colour -t age)
+      opts = Kat::Options.parse args
+
+      args.must_equal ['foobar']
+
+      opts[:or].must_equal %w(baz)
+      opts[:sort].must_equal 'age'
+      %i(colour colour_given or_given sort_given).each { |key|
+        opts[key].must_equal true
+      }
+    end
+  end
+
+end

data/test/{kat_test.rb → kat/test_search.rb}

@@ -1,17 +1,17 @@
 require 'minitest/autorun'
-require 'kat'
+require File.dirname(__FILE__) + '/../../lib/kat/search'
 
-blue_peter = Kat.new
-blue_peter.do_search.do_search 1
+blue_peter = Kat.search
+blue_peter.go.go 1
 
-describe Kat do
+describe Kat::Search do
 
-  let(:kat) { Kat.new 'test' }
-  let(:kat_opts) { Kat.new 'test', { :category => 'books' } }
+  let(:kat) { Kat.search 'test' }
+  let(:kat_opts) { Kat.search 'test', { category: 'books' } }
 
   describe 'basic search' do
     it 'returns a full result set' do
-      Kat.search('test').size.must_equal 25
+      Kat.quick_search('test').size.must_equal 25
     end
   end
 
@@ -23,25 +23,25 @@ describe Kat do
       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 = [0, {}, [:test, 0..1, ['user:foo']]]
       kat_opts.query_str(1).must_equal 'usearch/test user:foo category:books/2/'
     end
 
     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'
+      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 files:2 seeds:2 safe:1 category:books lang_id:2/2/?field=files_count&sorder=asc'
     end
 
     it 'wont respond to result fields before a search' do
-      [ :titles, :files ].each do |s|
+      %i(titles files).each { |s|
         kat.respond_to?(s).must_equal false
-      end
+      }
     end
 
     it 'responds to result fields after a search' do
-      [ :titles, :files ].each do |s|
+      %i(titles files).each { |s|
         blue_peter.respond_to?(s).must_equal true
-      end
+      }
     end
 
     it 'returns identical result sets' do
@@ -55,8 +55,8 @@ describe Kat do
 
     it 'returns a valid query string with options' do
       bp = blue_peter.dup
-      bp.options = { :user => :foobar }
-      bp.options.must_equal({ :user => :foobar })
+      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)
@@ -71,7 +71,7 @@ describe Kat do
     end
 
     it 'works when there are fewer than 25 results' do
-      kat.options = { :category => :wallpapers }
+      kat.options = { category: :wallpapers }
       kat.search.wont_be_nil
       kat.search.size.wont_equal 0
       kat.pages.must_equal 1
@@ -80,43 +80,41 @@ describe Kat do
     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 'field options' do
     it 'returns a list of time added options' do
-      times = Kat.times
+      times = Kat::Search.times
       times.must_be_instance_of Hash
       times.wont_be_empty
       times[:error].must_be_nil
     end
 
     it 'returns a list of categories' do
-      categories = Kat.categories
+      categories = Kat::Search.categories
       categories.must_be_instance_of Hash
       categories.wont_be_empty
       categories[:error].must_be_nil
     end
 
     it 'returns a list of languages' do
-      languages = Kat.languages
+      languages = Kat::Search.languages
       languages.must_be_instance_of Hash
       languages.wont_be_empty
       languages[:error].must_be_nil
     end
 
     it 'returns a list of platforms' do
-      platforms = Kat.platforms
+      platforms = Kat::Search.platforms
       platforms.must_be_instance_of Hash
       platforms.wont_be_empty
       platforms[:error].must_be_nil
     end
 
     it 'returns an error' do
-      Kat.field_options(:foobar)[:error].must_be_instance_of RuntimeError
+      Kat::Search.class_exec { field_options :foobar }[:error].must_be_instance_of RuntimeError
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kat
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Fission Xuiptz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-14 00:00:00.000000000 Z
+date: 2013-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -68,8 +68,17 @@ files:
 - bin/kat
 - kat.gemspec
 - lib/kat.rb
+- lib/kat/app.rb
+- lib/kat/colour.rb
+- lib/kat/field_map.rb
+- lib/kat/options.rb
+- lib/kat/search.rb
 - lib/kat/version.rb
-- test/kat_test.rb
+- test/kat/test_app.rb
+- test/kat/test_colour.rb
+- test/kat/test_field_map.rb
+- test/kat/test_options.rb
+- test/kat/test_search.rb
 homepage: http://github.com/fissionxuiptz/kat
 licenses:
 - MIT
@@ -95,4 +104,8 @@ signing_key:
 specification_version: 4
 summary: Kickass Torrents Interface
 test_files:
-- test/kat_test.rb
+- test/kat/test_app.rb
+- test/kat/test_colour.rb
+- test/kat/test_field_map.rb
+- test/kat/test_options.rb
+- test/kat/test_search.rb