gotasku 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3a96fbb30bae291ebd35b1b6b7afb2ef18b1588a
+  data.tar.gz: 0ac6145dd789670da679de4e8e3b8f8d4ef6ac14
+SHA512:
+  metadata.gz: 87b2eab023c391a130c2839167b7380e3e0a9371220f8a0e4e454c1d1b0d6b9e54b2e2330b9bf34b89736db79542041f1cc6480377bc5ec297bc40b3c7869fe5
+  data.tar.gz: 7c10a24044927d1dd28f6b70e7ed43a6a10160568e14c965eff37af71f783b252256250a945690ebf615b98026d50b7e29cdb55981d65846574ad3874ebe05e6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 John Hager
+
+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,116 @@
+gotasku
+=======
+
+Saving and opening tsumego
+
+	_Use_
+
+  *Problem*
+
+	New problem. You can provide "id", "sgf", or "data" options.
+		"id" => Integer (id of goproblem.com problem)
+		"sgf" => String or File of SGF
+		"data" => Hash with any of the following keys 
+							("id", "sgf", "difficulty", 
+							 "diff_num", "type", "rating") 
+
+	Gotasku::Problem.new(options)
+
+	Gotasku::Problem.new("id" => 1000)
+
+	Gotasku::Problem.new("sgf" => "problem.sgf")
+	Gotasku::Problem.new("sgf" => "(;AB[aa]AW[ab]")
+
+	Gotasku::Problem.new("data" => {"id" => 1000,
+																	"sgf" => "(;AB[aa]AW[ab])",
+																	"difficulty" => "6 dan",
+																	"diff_num" => -6,
+																	"type" => "life and death",
+																	"rating" => 3})
+
+	You can access Problem data with #sgf, #id, #difficulty, #type, 
+	 #rating, and #data instance methods
+
+	prob = Gotasku::Problem.new("id" => 10000)
+	prob.data
+	prob.difficulty
+
+	Gotasku use SgfParser to parse the SGF and save it.
+
+	You can get the tree from SGF with the #tree instance method
+
+	prob.tree
+
+	And you can save the file with the #save instance method 
+
+	prob.save
+
+	The file will be saved as "#{id}.sgf" or using a time stamp if no id.
+
+	\*see MongoDB for more
+
+
+	*User*
+
+	You can create a user object.
+
+	user = Gotasku::User.new('username', 'password')
+
+	*Session*
+
+	You can login to goproblems.com by creating a new session object.
+	The current session is saved in the @@current\_session class variable 
+
+	Gotasku::Session.new(user)
+
+
+	_*For MongoDB*_
+
+	If you have MongoDB installed, you can run the rake tasks from the 
+	root directory of the gem:
+
+	rake db:create
+	rake problems
+
+	The first will create the database, the second will populate a 
+	collection with all the go problems from goproblems.com.
+
+	_Querying_
+
+	You can build a query with Gotasku::Query.create (you will be 
+  prompted on how you want to filter the problems collection.
+
+	Gotasku::Query.create
+
+	Or you can query the collection directly 
+  Gotasku::Query.new(query\_hash)
+
+	Gotasku::Query.new({"id" => 1000})
+
+	This returns a Gotasku::Query object, with an instance variable 
+  (@found) that holds the Mongo::Cursor object from the query.
+
+	query = Gotasku::Query.new({"type" => "life and death"})
+	query.found 
+
+	Gotasku::Query has a #to\_a instance method to get an array from the
+	Mongo::Cursor object.
+
+	query.to\_a
+
+	*Problem* 
+
+	index = 0
+	Gotasku::Problem.new("data", query.to\_a[index])
+
+  _Executable_
+
+  There is an executable in the bin folder, which you can add to your 
+  PATH. It provides commands for getting data from or saving single 
+  problems.
+
+  Use the help option to get more info:
+
+  $ path/to/gem/bin/gotasku --help  
+ 
+

data/bin/gotasku

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+require_relative "../lib/gotasku"
+
+def get_help
+  puts "\"gotasku #{ARGV.join(" ")}\" isn't a command I know."
+  puts "Try `gotasku --help`"
+end
+
+def problem(options)
+  Gotasku::Problem.new(options)
+end
+
+def prompt(text)
+	print(text)
+	$stdin.gets.chomp.strip
+end
+
+problem_commands = %w[ display sgf id save data difficulty 
+                       rating type ]
+session_commands = %w[ login ]
+rake_commands    = %w[ test ]
+
+options = {}
+optparse = OptionParser.new do |opts|
+
+	opts.banner = "Gotasku"
+	opts.separator  ""
+	opts.separator  "Problem Commands"
+	problem_commands.each do |c|
+		opts.separator  "   #{c}" 
+	end
+	
+	opts.separator  ""
+	opts.separator  "Options"
+
+	options["id"] = nil 
+	opts.on( '-i', '--id Num', Integer, "Provide the problem id" ) do |id|
+		  options["id"] = id 
+	end
+
+  options["sgf"] = nil 
+	opts.on( '-s', '--sgf String|FILE', 
+					"Provide the problem SGF" ) do |sgf|
+		  options["sgf"] = sgf 
+	end
+
+  opts.separator "Session Commands"
+	session_commands.each do |c|
+		opts.separator  "   #{c}" 
+	end
+
+	opts.separator "Options"
+  options[:username] = nil 
+	opts.on( '-u', '--username Username', 
+					"Provide your Username" ) do |username|
+		  options[:username] = username 
+	end
+	
+  options[:password] = nil 
+	opts.on( '-p', '--password Password', 
+					"Provide your Password" ) do |password|
+		  options[:password] = password 
+	end
+
+	opts.separator "Other Commands"
+	rake_commands.each do |c|
+		opts.separator  "   #{c}" 
+	end
+
+	opts.separator "Help"
+	opts.on("-h","--help","help") do
+	  puts optparse
+	end
+end
+
+optparse.parse!
+
+# if multiple commands are given
+if ARGV.length > 1
+	get_help
+	exit
+end
+
+if session_commands.include?(ARGV[0])
+	options[:username] ||= prompt("Username: ")
+	options[:password] ||= prompt("Password: ")
+
+	user = Gotasku::User.new(options[:username], options[:password])
+	p Gotasku::Session.new(user)
+elsif problem_commands.include?(ARGV[0])
+	p problem(options).send(ARGV[0].to_sym)
+elsif rake_commands.include?(ARGV[0])
+	puts `rake`
+elsif ARGV[0].nil?
+	p problem(options)
+else
+	get_help
+end

data/db/tasks/db-tasks.rb

@@ -0,0 +1,19 @@
+require 'rake'
+require 'mongo'
+
+require_relative 'populate_database'
+
+namespace :db do
+	desc "Create the database"
+	task :create do
+		client = Mongo::MongoClient.new
+		db = client.db('sgf') 
+		collection = db.collection('owner')
+		collection.insert({name: "John"})
+	end
+
+  desc "Drop the database"
+	task :drop do
+		Mongo::MongoClient.new.drop_database('sgf')
+	end
+end

data/db/tasks/populate_database.rb

@@ -0,0 +1,46 @@
+require 'rake'
+require 'mongo'
+require_relative '../../lib/gotasku'
+
+namespace :problems do
+  desc "Populate the problems collection"
+	task :populate do
+		client = Mongo::MongoClient.new
+		db = client.db('sgf')
+		collection = db.collection('problems')
+
+		(0..Gotasku::Problem.last_problem_id).each do |id|
+			if collection.find(id: id).first
+				print '_'
+				next
+			end
+
+			prob = Gotasku::Problem.new(id: id)
+
+			begin 
+				if prob.blank? == false 
+					collection.insert(prob.data) 
+					print '.'
+				else
+					print '*'
+				end
+			rescue
+				print 'E'
+			end
+		end
+	end
+
+	desc "Structure the problems collection"
+	task :structure do
+		collection = Mongo::MongoClient.new.db('sgf').collection('problems')
+		collection.ensure_index( 
+														{id: Mongo::ASCENDING}, 
+														{unique: true, dropDups: true})
+		collection.create_index(diff_num: Mongo::DESCENDING)
+		collection.create_index(rating: Mongo::DESCENDING)
+		collection.create_index("type")
+	end
+
+	desc "Populate and structure problems collection"
+  task default: [:populate, :structure]	
+end

data/lib/gotasku.rb

@@ -0,0 +1,17 @@
+require 'open-uri'
+require 'nokogiri'
+require 'sgf'
+require 'mechanize'
+require 'mongo'
+
+require_relative 'gotasku/gotasku'
+
+require_relative 'gotasku/exceptions'
+require_relative 'gotasku/problem'
+require_relative 'gotasku/difficulty_string'
+require_relative 'gotasku/rating_string'
+require_relative 'gotasku/display'
+require_relative 'gotasku/parser'
+require_relative 'gotasku/user'
+require_relative 'gotasku/session'
+require_relative 'gotasku/query'

data/lib/gotasku/difficulty_string.rb

@@ -0,0 +1,22 @@
+class Gotasku::DifficultyString < String
+
+	# convert difficulty string to number
+	def convert 
+	  case self
+		when /p/ #pro
+			# grab number, mulitply by -1 and subtract 10 
+			(self.slice(/\d+/).to_i * -1) - 10
+		when /d/ #dan
+			# grab number, multiply by -1 
+	  	(self.slice(/\d+/).to_i * -1)
+		when /k/ #kyu
+		  # grab number	
+		  self.slice(/\d+/).to_i	
+		else
+			nil
+		end
+	end
+end
+
+			
+

data/lib/gotasku/display.rb

@@ -0,0 +1,26 @@
+class Gotasku::Display 
+	def self.show_problem(problem)
+    puts "=" * 40
+	  puts "id: #{problem.id}"
+	  puts "type: #{problem.type}"
+		puts "rating: #{problem.rating}"
+		puts "difficulty: #{problem.difficulty}"
+		puts "=" * 40
+	end
+
+	def self.show_list(list)
+		list.each_with_index {|item, i| puts "#{i}...#{item}"}
+	end	
+
+	def self.show(object)
+		case object
+		when ::Gotasku::Problem
+			self.show_problem(object)
+		when ::Array
+			self.show_list(object)
+		else
+			puts "Sorry, I can't show that.."
+		end
+	end
+end
+

data/lib/gotasku/exceptions.rb

@@ -0,0 +1,5 @@
+class Gotasku::NotFound < Exception
+end
+
+class Gotasku::InvalidEntry < Exception
+end

data/lib/gotasku/gotasku.rb

@@ -0,0 +1,4 @@
+class Gotasku 
+
+end
+

data/lib/gotasku/parser.rb

@@ -0,0 +1,28 @@
+class Gotasku::Parser < SGF::Parser
+
+	# validates and parses sgf string
+	def parse(sgf)
+    super(validate(sgf))	
+	end
+
+	# validates sgf string for common goproblems.com issues
+	def validate(sgf)
+	  validate_for(validate_for(sgf, :AB), :AW)
+	end
+
+	# validates for a property (AB or AW)
+	def validate_for(sgf, property)
+		regs = {AB: /AB/, AW: /AW/}
+
+		# find the first instance, all will be replaced and the first 
+		# instance will be readded
+		start = sgf =~ regs[property] 
+
+		if start
+			sgf.gsub!(regs[property], '')
+			sgf = sgf[0...start] + property.to_s + sgf[start..-1]
+		end
+
+		sgf
+	end
+end

data/lib/gotasku/problem.rb

@@ -0,0 +1,151 @@
+class Gotasku::Problem
+
+	@@uri = "http://www.goproblems.com/"
+
+	attr_reader :id
+
+	# initializes with a hash of options
+	def initialize(options = {})
+		@id   = options["id"]
+		@sgf  = options["sgf"]
+
+		if @sgf 
+			# checks if sgf is a sgf file, and reads it if it is
+      if @sgf =~ /\.sgf/ && File.exists?(@sgf)
+				@sgf = File.open(@sgf, 'r').read
+			end
+
+			@data ||= {}
+		end
+
+	  # overrides sgf and id if they are provided in the option data	
+		if options["data"]
+			@data = options["data"]
+			@id   = @data["id"]  || @id
+			@sgf  = @data["sgf"] || @sgf
+		end
+	end
+
+  # get the id of the last problem on goproblems.com
+	def self.last_problem_id
+		@@last_problem_id ||= begin
+			doc = Nokogiri::HTML(open('http://www.goproblems.com/').read)
+			link = doc.css('td a').select {|a| a[:href] =~ /^\/\d+\z/}[0]
+		  link[:href].slice(/\d+/).to_i
+		end
+	end
+	
+	# print out information on problem on screen
+	def display 
+		Gotasku::Display.show(self)
+	end
+
+	# access sgf or strip problem sgf from goproblems.com 
+	def sgf
+		@sgf ||= data["sgf"]
+	end
+
+	# strip problem difficulty from goproblems.com
+	def difficulty
+		data["difficulty"]
+	end
+
+	# strip problem type from goproblems.com
+	def type 
+		data["type"]
+	end
+
+	# strip problem rating from goproblems.com 
+	def rating 
+		data["rating"]
+	end
+
+	# access or get the tree from the Parser
+	def tree 
+		@tree ||= Gotasku::Parser.new.parse(sgf)
+	end
+
+	# saves the sgf 
+	def save
+		tree.save("#{id || Time.now.to_i}.sgf")
+	end
+
+	# this method is not finished
+	# uploads sgf to goproblems.com 
+	def upload
+		# don't upload a problem that came from goproblems
+		unless @id
+			sess = Gotasku::Session.current
+
+			add_info_page = sess.link_with(href: /add/).click
+			add_page = add_info_page.link_with(text: /direct/).click
+
+      add_page.form_with(
+				action: 'addtest.php3') do |f|
+				source_field = f.field_with(name: "source")
+				source_field.value = ''
+				
+				name_field = f.field_with(name: "name")
+				name_field.value = '' 
+
+				sgf_field = f.field_with(name: "sgf")
+				sgf_field.value = @sgf
+				
+				intro_field = f.field_with(name: "intro")
+				intro_field.value = ''
+
+        type_select = f.field_with(name: "genre")
+				type_select.value = 'elementary' 
+				
+				group_select = f.field_with(name: "usergroup[]")
+				group_select.value = ['none']
+
+				@submit = f.submit
+			end
+
+			# after submit, goes to flash app to confirm and complete 
+			# the problem
+		end
+	end
+
+	def blank?
+		sgf == '(;)'
+	end
+
+	def data 
+		@data ||= begin
+			# get sgf from go problems  
+			doc = Nokogiri::HTML(open("#{@@uri}#{@id}").read) 
+			sgf_text = doc.css("div#player-container").text.gsub(/\r?\n/, '')
+
+			raise Gotasku::NotFound if sgf_text.empty?
+
+			difficulty = Gotasku::DifficultyString.new(
+										doc.css("div.difficulty a").text)
+			type = doc.css("div.prob_genre").text
+			rating = Gotasku::RatingString.new(
+								doc.css("div.probstars")[0][:class]).convert
+
+			{
+				"id"         => @id,
+				"sgf"        => sgf_text, 
+				"difficulty" => difficulty, 
+				"diff_num"   => difficulty.convert,
+				"type"       => type, 
+				"rating"     => rating
+			}
+
+		rescue Gotasku::NotFound
+			# puts "This problem cannot be found"
+
+			# at the moment, this seems the best solution, not ideal though
+			# because it allows for problems to be saved even if they are not 
+			# found
+			{sgf: '(;)'}
+
+		rescue SocketError
+			puts "Poor internet connection"
+			{sgf: '(;)'} 
+		end
+	end
+end

data/lib/gotasku/query.rb

@@ -0,0 +1,106 @@
+class Gotasku::Query 
+	@@problems = Mongo::MongoClient.new.db('sgf').collection('problems')
+
+	attr_reader :found
+
+	# gets a Mongo::Cursor object
+	def initialize(query)
+		@found = @@problems.find(query) 
+	end
+
+	# returns an array of items in @found
+	def to_a 
+		@found.rewind!
+		@found.to_a
+	end
+
+	# returns a Mongo::Cursor object
+	def self.create
+		self.new(self.build_query)
+	end
+
+=begin
+	# key is a string or symbol
+	def self.sort_by(key)
+	end
+
+	# query is a hash 
+	def self.query_by(query)
+	end
+=end
+
+	private
+	  # prompts user for input
+		def self.prompt(text, tru = nil, fals = nil)
+			print text
+
+			response = gets.chomp.strip.downcase
+
+      # if values are given to verrifying input as true/false
+			if tru and fals 
+				if response =~ /#{tru}/
+					true
+				elsif response =~ /#{fals}/
+					false
+				else
+					nil
+				end
+			else # else return an Array
+				response = response.split(',')
+
+				# throw an exception if the input is invalid
+				unless response.class == Array and 
+					     not(response.find {|item| item =~ /[a-z]/})
+					raise Gotasku::InvalidEntry
+				end
+
+				response.collect {|item| item.to_i}
+			end
+		end
+
+	  #gets unique set of types from collection
+		def self.get_types
+			@@problems.distinct(:type).sort
+		end
+
+		#gets unique set of difficulties from collection
+		def self.get_difficulties
+			@@problems.distinct(:difficulty).sort do |x, y| 
+				x = Gotasku::DifficultyString.new(x).convert
+				y = Gotasku::DifficultyString.new(y).convert
+				x <=> y
+			end
+		end
+		
+	  #gets unique set of ratings from collection
+		def self.get_ratings
+			@@problems.distinct(:rating).sort
+		end
+
+	  # runs a prompt to build a query for the database
+		def self.build_query
+			query_build = {} 
+			q = {
+						type:       -> {self.get_types},
+						difficulty: -> {self.get_difficulties},
+						rating:     -> {self.get_ratings}
+			    }
+
+			q.keys.each do |key|
+				if self.prompt("Do you want to filter by #{key} (y/n)? ", 
+											 'y', 'n')
+					list = q[key].call
+					Gotasku::Display.show(list)
+					puts '=' * 40
+					values = self.prompt(
+						"Please type the index/number for the values " +
+					  "you would like to filter for (e.g. 0, 3, 4): ")
+
+					values.collect! {|value| list[value]}
+					query_build[key] = { "$in" => values }
+				end
+			end
+
+			query_build
+		end
+end

data/lib/gotasku/rating_string.rb

@@ -0,0 +1,11 @@
+class Gotasku::RatingString < String 
+
+	# convert string to number
+	def convert 
+		sum = self.slice(/sitesum:\d+/).slice(/\d+/).to_i
+		num = self.slice(/sitenum:\d+/).slice(/\d+/).to_i
+
+		# find the average or return the sum (if num is 0)
+		num == 0 ? 0 : sum / num 
+	end
+end

data/lib/gotasku/session.rb

@@ -0,0 +1,35 @@
+class Gotasku::Session
+
+	@@current = nil
+
+	attr_reader :account
+	
+	# uses mechanize to login to goproblems.com and makes makes this the
+	# current session
+	def initialize(user)
+		a = Mechanize.new
+		a.get('http://www.goproblems.com/') do |page|
+			# Click the login link
+			login_page = a.click(page.link_with(href: /login/))
+
+			# Submit the login form
+			login_page.form_with(
+								action: 'login.php') do |f|
+				username_field = f.field_with(name: "name")
+				username_field.value = user.username
+				
+				password_field = f.field_with(name: "password")
+				password_field.value = user.password 
+
+				@account = f.submit
+			end
+		end
+
+		@@current = @account
+	end
+
+	# accesses current session
+	def self.current 
+		@@current
+	end
+end

data/lib/gotasku/user.rb

@@ -0,0 +1,11 @@
+class Gotasku::User 
+
+	attr_reader :username, :password
+
+	# initializes a new user with all the info needed to create a new
+	# session
+	def initialize(username, password)
+		@username = username
+		@password = password
+	end
+end

data/rakefile

@@ -0,0 +1,11 @@
+require_relative 'db/tasks/db-tasks.rb' 
+
+task :run_all_tests do
+	Dir.glob('test/*.rb').each {|file| load file}
+end
+
+task :delete_sgfs do
+	Dir.glob('*.sgf').each {|file| File.delete(file)}
+end
+
+task default: [:run_all_tests]

data/test/cli.rb

@@ -0,0 +1,77 @@
+require_relative '../lib/gotasku'
+
+require 'minitest/autorun'
+require 'stringio'
+
+
+load 'variables.rb' # username and password for testing
+
+class GotaskuCLITest < MiniTest::Unit::TestCase
+
+	def test_get_problem
+	  io = StringIO.new
+		io.puts(`./bin/gotasku`)
+		io.rewind
+		assert_match /Gotasku::Problem/, io.read
+	end
+
+	def test_get_problem_with_id
+		io = StringIO.new
+		io.puts(`./bin/gotasku --id 1000`)
+		io.rewind
+		assert_match /@id=1000/, io.read
+	end
+
+	def test_get_problem_with_sgf
+		io = StringIO.new
+		io.puts(`./bin/gotasku --sgf '(;AB[aa][bb][cc]AW[dd][ee])'`)
+		io.rewind 
+		assert_includes io.read, "AB[aa][bb][cc]AW[dd][ee]" 
+	end
+
+	def test_get_problem_with_sgf_from_file
+		File.open('./test/john.sgf', 'w') {|f| f.write('(;AW[cc][cd][ad]AB[aa])')}
+    io = StringIO.new
+		io.puts(`./bin/gotasku --sgf ./test/john.sgf`)
+		io.rewind 
+		assert_includes io.read, "AW[cc]" 
+	end
+
+  def test_save_problem
+    name = '1000.sgf'
+
+		File.delete(name) if File.exists?(name) 
+		`./bin/gotasku save --id 1000 --sgf '(;AB[aa][bb][cc]AW[ab][bc][cd])'`
+		assert_includes Dir.glob('*.sgf'), name 
+	end
+
+  def test_display_problem_data
+		io = StringIO.new
+		io.puts(`./bin/gotasku display --id 1000`)
+		io.rewind
+		output = io.read
+		assert_match /id: 1000/, output
+		assert_match /type: life and death/, output
+		assert_match /rating: 3/, output
+		assert_match /difficulty: 6 dan/, output
+	end
+
+	def test_login
+		io = StringIO.new
+		io.puts(`./bin/gotasku login --username #{::USERNAME} --password #{::PASSWORD}`)
+    io.rewind
+		assert_match /Gotasku::Session/, io.read
+	end
+
+=begin
+  def test_get_problems_list_by_difficulty
+	end
+
+  def test_get_problems_list_by_rating
+	end
+
+  def test_get_problems_list_by_type
+	end
+=end
+end
+

data/test/parser.rb

@@ -0,0 +1,81 @@
+require 'minitest/autorun'
+require_relative '../lib/gotasku'
+
+class GotaskuParserTest < MiniTest::Unit::TestCase
+	def setup
+		@parser = SGF::Parser.new
+		@gparser = Gotasku::Parser.new
+	end
+
+	def test_initialize_parser
+		assert_kind_of Gotasku::Parser, Gotasku::Parser.new
+	end
+
+  def test_inherits_for_sgf_parser
+		assert_includes Gotasku::Parser.ancestors, SGF::Parser
+	end
+
+	def test_parses_correct_sgf
+		sgf = '(;AB[lb][lc][ld][kc][jb][ka][ck][dg][ei])'
+
+		assert_equal @parser.parse(sgf), @gparser.parse(sgf)  
+	end
+
+	def test_validates_sgf
+    correct_sgf = '(;AB[lb][lc][ld])'
+		incorrect_sgf = '(;AB[lb]AB[lc]AB[ld])'
+
+		assert_equal correct_sgf, @gparser.validate(incorrect_sgf)
+	end
+
+	def test_validates_sgf_with_AB_and_AW
+ 		correct_sgf = '(;AB[lb][lc][ld]AW[bb][cc])'
+		incorrect_sgf = '(;AB[lb]AB[lc]AB[ld]AW[bb]AW[cc])'
+
+		assert_equal correct_sgf, @gparser.validate(incorrect_sgf)
+	end
+
+	def test_parses_incorrect_sgf
+		correct_sgf = '(;AB[bb][bb][bb])'
+		incorrect_sgf = '(;AB[bb]AB[bb]AB[bb])'
+
+		assert_equal @parser.parse(correct_sgf), 
+			           @gparser.parse(incorrect_sgf)
+	end
+
+	def test_parses_incorrect_sgf_with_AB_and_AW
+		correct_sgf = '(;AB[lb][lc][ld]AW[bb][cc])'
+		incorrect_sgf = '(;AB[lb]AB[lc]AB[ld]AW[bb]AW[cc])'
+    
+		assert_equal @parser.parse(correct_sgf), 
+			           @gparser.parse(incorrect_sgf)
+	end
+
+	def test_full_incorrect_sgf_AB
+		incorrect_sgf = '(;AW[pe]AW[pf]AW[qg]AW[qh]AW[oi]AW[ri]AW[oj]AW[pj]AW[rj]AW[sk]AW[rl]AW[sl]AW[rm]AB[pg]AB[ph]AB[rh]AB[pi]AB[qi]AB[qj]AB[pk]AB[qk]AB[rk]AB[pl]C[black to do something effective on the side]SZ[19]GM[1]FF[3]RU[Japanese]HA[0]KM[5.5]PW[White]PB[Black]GN[White (W) vs. Black (B)]DT[1999-07-27]SY[Cgoban 1.9.2]TM[30:00(5x1:00)](;B[sh](;W[sj](;B[qf];W[rg];B[rf]C[RIGHT])(;B[rg];W[qf]))(;W[rg];B[sj];W[si];B[sj]C[snapbackRIGHT]))(;B[sj];W[si](;B[sh];W[sj](;B[qf];W[rg])(;B[rg];W[qf]))(;B[qf];W[rg])(;B[rg];W[qf]))(;B[rg];W[qf]C[black has nothing now])(;B[qf];W[rg](;B[sh];W[sg])(;B[rf];W[sh]))(;B[sj];W[si](;B[sh];W[sj](;B[qf];W[rg])(;B[rg];W[qf]))(;B[qf];W[rg])(;B[rg];W[qf]))(;B[qn];W[rg])(;B[qm];W[rg])(;B[rn];W[rg])(;B[rf];W[rg])(;B[sg];W[rg]))'
+		
+		validated_sgf = @gparser.validate(incorrect_sgf)
+
+		refute_match /AB\[..\]AB/, validated_sgf 
+		assert_match /AB/, validated_sgf
+	end
+
+	def test_full_incorrect_sgf_AW
+    incorrect_sgf = '(;AW[pe]AW[pf]AW[qg]AW[qh]AW[oi]AW[ri]AW[oj]AW[pj]AW[rj]AW[sk]AW[rl]AW[sl]AW[rm]AB[pg]AB[ph]AB[rh]AB[pi]AB[qi]AB[qj]AB[pk]AB[qk]AB[rk]AB[pl]C[black to do something effective on the side]SZ[19]GM[1]FF[3]RU[Japanese]HA[0]KM[5.5]PW[White]PB[Black]GN[White (W) vs. Black (B)]DT[1999-07-27]SY[Cgoban 1.9.2]TM[30:00(5x1:00)](;B[sh](;W[sj](;B[qf];W[rg];B[rf]C[RIGHT])(;B[rg];W[qf]))(;W[rg];B[sj];W[si];B[sj]C[snapbackRIGHT]))(;B[sj];W[si](;B[sh];W[sj](;B[qf];W[rg])(;B[rg];W[qf]))(;B[qf];W[rg])(;B[rg];W[qf]))(;B[rg];W[qf]C[black has nothing now])(;B[qf];W[rg](;B[sh];W[sg])(;B[rf];W[sh]))(;B[sj];W[si](;B[sh];W[sj](;B[qf];W[rg])(;B[rg];W[qf]))(;B[qf];W[rg])(;B[rg];W[qf]))(;B[qn];W[rg])(;B[qm];W[rg])(;B[rn];W[rg])(;B[rf];W[rg])(;B[sg];W[rg]))'
+		
+		validated_sgf = @gparser.validate(incorrect_sgf)
+		
+		refute_match /AW\[..\]AW/, validated_sgf 
+		assert_match /AW/, validated_sgf
+	end
+
+	def test_does_not_start_with_stone_positions
+		incorrect_sgf = '(;GM[1]FF[3]RU[Japanese]SZ[19]HA[0]KM[5.5]PW[White]PB[Black]GN[White (W) vs. Black (B)]DT[1999-07-28]SY[Cgoban 1.9.2]TM[30:00(5x1:00)];AW[ba]AW[ca]AW[ea]AW[bb]AW[eb]AW[cc]AW[ec]AW[ed]AW[ce]AW[de]AW[ee]AB[fa][fb][fc][bd][cd][dd][fd][be][fe][bf][cf][df][ef][ff](;B[dc];W[db];B[bc];W[ab]C[only ko])(;B[db];W[dc];B[ab];W[ac];B[bc]C[RIGHT])(;B[bc];W[db];B[dc];W[ab]C[only ko])(;B[ab];W[db](;B[dc];W[bc])(;B[bc];W[dc]))(;B[ac];W[ab]))'
+
+		validated_sgf = @gparser.validate(incorrect_sgf)
+	
+		assert_match /AW/, validated_sgf
+		refute_match /AW\[..\]AW/, validated_sgf
+	end
+
+end

data/test/problem_features.rb

@@ -0,0 +1,27 @@
+require 'minitest/autorun'
+require_relative '../lib/gotasku'
+
+class GotaskuFeatureTest < MiniTest::Unit::TestCase
+	def setup
+		@problem = Gotasku::Problem.new("id" => 1000)
+	end
+
+	def test_gets_difficulty
+		# 30k-1k, 1d-9d, 1p-9p => 30 - 1, -1 - -9, -11 - -19
+		assert_equal '6 dan', @problem.difficulty 
+	end
+
+  def test_gets_difficulty_conversion_for_sorting
+		# 30k-1k, 1d-9d, 1p-9p => 30 - 1, -1 - -9, -11 - -19
+		assert_equal -6, @problem.difficulty.convert 
+	end
+
+	def test_gets_type
+		assert_equal @problem.type, 'life and death'
+	end
+
+	def test_gets_rating 
+		assert_equal @problem.rating, 3
+	end
+end
+

data/test/query.rb

@@ -0,0 +1,52 @@
+require_relative '../lib/gotasku'
+
+require 'minitest/autorun'
+
+require 'mongo'
+require 'stringio'
+
+class GotaskuQueryTest < MiniTest::Unit::TestCase
+
+	def test_makes_query
+		query = Gotasku::Query.new({"id" => 1000})
+		assert_kind_of Mongo::Cursor, query.found
+	end
+
+	def test_builds_query
+		output = StringIO.new
+		file = StringIO.new
+		file << "y\n" << "1, 3\n" << "y\n" 
+		file << "9, 15, 1\n" << "y\n" << "3\n"  
+		file.rewind
+
+		temp_in  = $stdin
+		temp_out = $stdout
+		$stdin   = file
+		$stdout  = output
+
+		query = Gotasku::Query.create
+
+		$stdin  = temp_in
+		$stdout = temp_out
+
+		assert_kind_of Mongo::Cursor, query.found
+	end
+
+	def test_handles_big_query
+    query = Gotasku::Query.new({
+			                          "id" => {"$lt" => 15000},
+																"diff_num" => {"$gt" => 1, "$lt" => 9},
+																"rating" => {"$in" => 
+																	          ["life and death",
+																             "elementary"]}
+															})
+		assert_kind_of Mongo::Cursor, query.found
+	end
+
+	def test_new_problem_from_database
+		query = Gotasku::Query.new({"id" => 17642})
+		prob = Gotasku::Problem.new("data" => query.to_a.first)
+		assert prob.sgf 
+		assert prob.id
+	end
+end

data/test/sessions.rb

@@ -0,0 +1,16 @@
+require 'minitest/autorun'
+require_relative '../lib/gotasku'
+
+require_relative '../variables'
+
+class GotaskuSessionTest < MiniTest::Unit::TestCase
+
+	def setup
+		@user = Gotasku::User.new(::USERNAME, ::PASSWORD)
+		@session = Gotasku::Session.new(@user)
+	end
+
+	def test_creates_session
+		assert_kind_of Gotasku::Session, @session
+	end
+end

data/test/sgf.rb

@@ -0,0 +1,79 @@
+require 'minitest/autorun'
+require_relative '../lib/gotasku'
+
+class GotaskuProblemTest < MiniTest::Unit::TestCase
+	def setup
+		@problem = Gotasku::Problem.new("id" => 17625)
+	end
+
+	def test_gets_id
+		assert_equal 17625, @problem.id
+	end
+
+	def test_gets_sgf
+		sgf = '(;AB[se]AB[rd]AB[qd]AB[qe]AB[qf]AB[qg]AB[oe]AB[oc]AB[pc]AB[ob]AW[mb]AW[mc]AW[me]AW[mg]AW[og]AW[ph]AW[qh]AW[rg]AW[re]AW[rf]AW[sc]AW[qc]AW[qb]AW[pb]AW[rb]AP[goproblems]
+(;B[ra]
+(;W[rc]
+(;B[sd];W[sa];B[sb]C[CHOICERIGHT])
+(;B[pa];W[qa])
+(;B[qa];W[pa])
+(;B[sa];W[sd])
+(;B[sb];W[qa]))
+(;W[sd];B[sb]C[RIGHT]))
+(;B[oa];W[sd])
+(;B[pa];W[sd])
+(;B[qa];W[pa])
+(;B[sa];W[sd])
+(;B[sb];W[rc]TR[sd]TR[sa])
+(;B[rc];W[sb]TR[sd]TR[pa]))'.gsub(/\r?\n/, '')
+
+		assert_equal sgf, @problem.sgf
+	end
+
+	def test_gets_another_sgf
+		sgf = '(;GM[1]FF[4]VW[]AP[Many Faces of Go:10.0]
+SZ[13]
+HA[0]
+ST[1]
+DT[2001-08-13]
+KM[0.0]
+RU[GOE]
+AB[lb][lc][ld][kc][jb][ka][ck][dg][ei][fb][fc][fd][ee][db][cd][ej][fk][fl][fh][eg][fg][lj][kk][jj][ij][md][lf][gm][fm][gc]
+AW[ib][jc][kd][jd][le][jf][hc][fi][gb][gd][fe][ff][ia][fj][gl][gk][gh][gg][jk][kg][lh][kl][ll][ik][me][ke][hm][hl]
+C[After the previous problem, Black has played at 1 rather than
+protecting his corner.  How can white punish him?
+]
+PL[W]LB[gc:A]
+(;W[mb]
+(;B[ma]
+(;W[la];B[ge];W[ma];B[mc];W[ja];B[ma];W[kb]
+C[White has given up too much when black plays A
+]LB[ge:A]
+)
+(;W[ja];B[kb];W[la]
+C[RIGHT
+]))
+(;B[ja];W[la]))
+(;W[ja];B[mb]
+C[Black is unconditionally alive.
+])
+(;W[ge];B[ja]
+C[Black has had another chance to repair his defect.
+]))'.gsub(/\r?\n/, '')
+
+		assert_equal sgf, Gotasku::Problem.new("id" => 1000).sgf
+	end
+
+	def test_gets_tree_for_sgf
+		assert_kind_of ::SGF::Tree, @problem.tree 
+	end
+
+	def test_saves_problem
+		file = Dir.pwd + '/17625.sgf'
+
+		File.delete(file) if File.exist?(file)
+		@problem.save
+
+		assert_includes Dir.glob(Dir.pwd + '/*.sgf'), file
+	end
+end

data/test/user.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require_relative '../lib/gotasku'
+
+require_relative '../variables'
+
+class GotaskuUserTest < MiniTest::Unit::TestCase
+
+	def setup
+		@user = Gotasku::User.new(::USERNAME, ::PASSWORD)
+	end
+
+	def test_creates_user
+		assert_kind_of Gotasku::User, @user
+	end
+end

data/variables.rb

@@ -0,0 +1,2 @@
+::USERNAME = 'moax'
+::PASSWORD = 'regah2'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: gotasku
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- jphager2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-31 00:00:00.000000000 Z
+dependencies: []
+description: A gem to download SGFs of go problems
+email: jphager2@gmail.com
+executables:
+- gotasku
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/gotasku
+- db/tasks/db-tasks.rb
+- db/tasks/populate_database.rb
+- lib/gotasku.rb
+- lib/gotasku/difficulty_string.rb
+- lib/gotasku/display.rb
+- lib/gotasku/exceptions.rb
+- lib/gotasku/gotasku.rb
+- lib/gotasku/parser.rb
+- lib/gotasku/problem.rb
+- lib/gotasku/query.rb
+- lib/gotasku/rating_string.rb
+- lib/gotasku/session.rb
+- lib/gotasku/user.rb
+- rakefile
+- test/cli.rb
+- test/parser.rb
+- test/problem_features.rb
+- test/query.rb
+- test/sessions.rb
+- test/sgf.rb
+- test/user.rb
+- variables.rb
+homepage: https://github.com/jphager2/gotasku
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Downloads SGFs of go problems
+test_files: []