frecon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f815f2ffe36eae99a451ce057c3f2bc41a355783
+  data.tar.gz: 0b415f99c4fdc44bc23236bd259cddec01bd505b
+SHA512:
+  metadata.gz: 86b2d39602ae88bce2c4c10312ac8f9f91f29170b8774104e954d7300bb6e56cecf97ee3d72ec6c5c7c656b7c9c100227efa72cf5df74849a1f944b176c13fb7
+  data.tar.gz: 0ce13da7ae08cffc748ad6e4ca3baa30e8a0606dfc98b5bc4131b7f59a2a24edc730540a028a2797ae780aed853d03fa87e9b108878465f1eac37a63611b7a89

data/bin/frecon

@@ -0,0 +1,13 @@
+#! /usr/bin/env ruby
+
+# Allow running locally.
+lib_directory = File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+$LOAD_PATH.unshift(lib_directory) unless $LOAD_PATH.include?(lib_directory)
+
+require "frecon"
+
+unless ARGV.include?("c") || ARGV.include?("console")
+	FReCon::Server.start
+else
+	FReCon::Console.start
+end

data/lib/frecon/base/object.rb

@@ -0,0 +1,3 @@
+class Object
+	alias_method :is_an?, :is_a?
+end

data/lib/frecon/base/variables.rb

@@ -0,0 +1,4 @@
+module FReCon
+	ENVIRONMENT = :development
+	VERSION = "0.1.0"
+end

data/lib/frecon/base.rb

@@ -0,0 +1,2 @@
+require "frecon/base/object"
+require "frecon/base/variables"

data/lib/frecon/console.rb

@@ -0,0 +1,28 @@
+require "frecon/database"
+require "frecon/server"
+
+module FReCon
+	class Console
+		def self.start
+			Database.setup
+
+			# Use pry if it is installed.
+			# Use the context of the FReCon module;
+			# this allows for writing "Team" instead of "FReCon::Team".
+			begin
+				require "pry"
+
+				FReCon.pry
+			rescue LoadError
+				require "irb"
+
+				IRB.setup nil
+				IRB.conf[:MAIN_CONTEXT] = IRB::Irb.new.context
+
+				require "irb/ext/multi-irb"
+
+				IRB.irb nil, FReCon
+			end
+		end
+	end
+end

data/lib/frecon/controller.rb

@@ -0,0 +1,129 @@
+require "frecon/base"
+
+module FReCon
+	class Controller
+		def self.model_name
+			# Removes the namespace "FReCon::" and "Controller" from
+			# the class name, then singularizes the result.
+			self.name.gsub(/FReCon::|Controller\Z/, "").singularize
+		end
+
+		def self.model
+			# Removes the trailing "Controller" from the class name,
+			# singularizes the result, and turns it into the class.
+			self.name.gsub(/Controller\Z/, "").singularize.constantize
+		end
+
+		# The 404 error message.
+		def self.could_not_find(value, attribute = "id", model = model_name.downcase)
+			"Could not find #{model_name.downcase} of #{attribute} #{value}!"
+		end
+
+		# Processes a POST/PUT request and returns the post data.
+		def self.process_request(request)
+			# Rewind the request body (an IO object)
+			# in case someone else has already played
+			# through it.
+			request.body.rewind
+
+			begin
+				# Parse the POST data as a JSON hash
+				# (because that's what it is)
+				post_data = JSON.parse(request.body.read)
+			rescue JSON::ParserError => e
+				# If we have malformed JSON (JSON::ParserError is
+				# raised), escape out of the function.
+				return [400, ErrorFormatter.format(e.message)]
+			end
+
+			post_data.is_an?(Array) ? [422, ErrorFormatter.format("Must pass a JSON object!")] : post_data
+		end
+
+		def self.create(request, params)
+			post_data = process_request request
+			return post_data if post_data.is_an?(Array)
+
+			@model = model.new
+			@model.attributes = post_data
+
+			if @model.save
+				[201, @model.to_json]
+			else
+				[422, ErrorFormatter.format(@model.errors.full_messages)]
+			end
+		end
+
+		def self.update(request, params)
+			return [400, "Must supply a #{model_name.downcase}!"] unless params[:id]
+
+			post_data = process_request request
+			return post_data if post_data.is_an?(Array)
+
+			@model = model.find params[:id]
+
+			return [404, ErrorFormatter.format(could_not_find(params[:id]))] unless @model
+
+			if @model.update_attributes(post_data)
+				@model.to_json
+			else
+				[422, ErrorFormatter.format(@model.errors.full_messages)]
+			end
+		end
+
+		def self.delete(params)
+			@model = model.find params[:id]
+
+			if @model
+				if @model.destroy
+					204
+				else
+					[422, ErrorFormatter.format(@model.errors.full_messages)]
+				end
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:id]))]
+			end
+		end
+
+		def self.show(params)
+			@model = model.find params[:id]
+
+			if @model
+				@model.to_json
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:id]))]
+			end
+		end
+
+		def self.index(params)
+			params.delete("_")
+
+			@models = params.empty? ? model.all : model.where(params)
+
+			@models.to_json
+		end
+
+		def self.show_attribute(params, attribute)
+			@model = model.find params[:id]
+
+			if @model
+				@model.send(attribute).to_json
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:id]))]
+			end
+		end
+
+		def self.team_number_to_team_id(post_data)
+			if post_data["team_number"] && !post_data["team_id"]
+				unless (team = Team.number post_data["team_number"]).nil?
+					post_data["team_id"] = team.id
+
+					post_data.delete("team_number")
+
+					post_data
+				else
+					return [404, ErrorFormatter.format(could_not_find(post_data["team_number"], "number", "team"))]
+				end
+			end
+		end
+	end
+end

data/lib/frecon/controllers/competitions_controller.rb

@@ -0,0 +1,18 @@
+require "json"
+require "frecon/models"
+
+module FReCon
+	class CompetitionsController < Controller
+		def self.teams(params)
+			show_attribute params, :teams
+		end
+
+		def self.matches(params)
+			show_attribute params, :matches
+		end
+
+		def self.records(params)
+			show_attribute params, :records
+		end
+	end
+end

data/lib/frecon/controllers/dump_controller.rb

@@ -0,0 +1,20 @@
+require "json"
+require "frecon/models"
+
+module FReCon
+	class DumpController
+		def self.full(params)
+			competitions = Competition.all
+			teams = Team.all
+			matches = Match.all
+			records = Record.all
+
+			{
+				"competitions" => competitions,
+				"teams" => teams,
+				"matches" => matches,
+				"records" => records
+			}.to_json
+		end
+	end
+end

data/lib/frecon/controllers/matches_controller.rb

@@ -0,0 +1,14 @@
+require "json"
+require "frecon/models"
+
+module FReCon
+	class MatchesController < Controller
+		def self.competition(params)
+			show_attribute params, :competition
+		end
+
+		def self.records(params)
+			show_attribute params, :records
+		end
+	end
+end

data/lib/frecon/controllers/participations_controller.rb

@@ -0,0 +1,28 @@
+module FReCon
+	class ParticipationsController < Controller
+		def self.create(request, params)
+			post_data = process_request request
+			return post_data if post_data.is_an?(Array)
+			
+			# Convert team number to team_id.
+			post_data = team_number_to_team_id(post_data)
+
+			@model = model.new
+			@model.attributes = post_data
+
+			if @model.save
+				[201, @model.to_json]
+			else
+				[422, ErrorFormatter.format(@model.errors.full_messages)]
+			end
+		end
+		
+		def self.competition(params)
+			show_attribute params, :competition
+		end
+		
+		def self.team(params)
+			show_attribute params, :team
+		end
+	end
+end

data/lib/frecon/controllers/records_controller.rb

@@ -0,0 +1,59 @@
+require "json"
+require "frecon/base"
+require "frecon/models"
+
+module FReCon
+	class RecordsController < Controller
+		def self.create(request, params)
+			post_data = process_request request
+			return post_data if post_data.is_an?(Array)
+
+			# Change special post_data attributes.
+			# Convert team number to team id.
+			post_data = team_number_to_team_id(post_data)
+
+			# Convert match number and competition name to match id.
+			if post_data["match_number"] && !post_data["match_id"]
+				if post_data["competition_name"] && (competition = Competition.find_by name: post_data["competition_name"])
+					# Try to set the match to the already existing match.
+					match = competition.matches.find_by number: post_data["match_number"]
+
+					# Create the match if necessary.
+					match ||= Match.create(number: post_data["match_number"], competition_id: competition.id)
+
+					post_data["match_id"] = match.id
+
+					post_data.delete("match_number")
+					post_data.delete("competition_name")
+				elsif post_data["competition"] && post_data["competition"]["_id"] && post_data["competition"]["_id"]["$oid"] && (competition = Competition.find_by(id: post_data["competition"]["_id"]["$oid"]))
+					# Try to set the match to the already existing match.
+					match = competition.matches.find_by number: post_data["match_number"]
+
+					# Create the match if necessary.
+					match ||= Match.create(number: post_data["match_number"], competition_id: competition.id)
+
+					post_data["match_id"] = match.id
+
+					post_data.delete("match_number")
+					post_data.delete("competition")
+				else
+					return [422, ErrorFormatter.format("A current competition is not set.  Please set it.")]
+				end
+			end
+
+			@record = Record.new
+			@record.attributes = post_data
+
+			if @record.save
+				# Use to_json for now; we can filter it later.
+				[201, @record.to_json]
+			else
+				[422, ErrorFormatter.format(@record.errors.full_messages)]
+			end
+		end
+
+		def self.competition(params)
+			show_attribute params, :competition
+		end
+	end
+end

data/lib/frecon/controllers/robots_controller.rb

@@ -0,0 +1,14 @@
+require "json"
+require "frecon/models/robot"
+
+module FReCon
+	class RobotsController < Controller
+		def self.competition(params)
+			show_attribute params, :competition
+		end
+
+		def self.team(params)
+			show_attribute params, :team
+		end
+	end
+end

data/lib/frecon/controllers/teams_controller.rb

@@ -0,0 +1,112 @@
+require "json"
+require "frecon/base"
+require "frecon/models"
+
+module FReCon
+	class TeamsController < Controller
+		def self.create(request, params)
+			post_data = process_request request
+			return post_data if post_data.is_an?(Array)
+
+			@team = Team.new
+			@team.attributes = post_data
+
+			if @team.save
+				# Use to_json for now; we can filter it later.
+				[201, @team.to_json]
+			else
+				[422, ErrorFormatter.format(@team.errors.full_messages)]
+			end
+		end
+
+		def self.update(request, params)
+			return [400, "Must supply a team number!"] unless params[:number]
+
+			post_data = process_request request
+			return post_data if post_data.is_an?(Array)
+
+			@team = Team.find_by number: params[:number]
+
+			if @team.nil?
+				return [404, ErrorFormatter.format(could_not_find(params[:number], "number"))]
+			end
+
+			if @team.update_attributes(post_data)
+				@team.to_json
+			else
+				[422, ErrorFormatter.format(@team.errors.full_messages)]
+			end
+		end
+
+		def self.delete(params)
+			@team = Team.find_by number: params[:number]
+
+			if @team
+				if @team.destroy
+					204
+				else
+					[422, ErrorFormatter.format(@team.errors.full_messages)]
+				end
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:number], "number"))]
+			end
+		end
+
+		def self.show(params)
+			@team = Team.find_by number: params[:number]
+
+			if @team
+				@team.to_json
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:number], "number"))]
+			end
+		end
+
+		def self.records(params)
+			@team = Team.find_by number: params[:number]
+
+			if @team
+				if params[:competition_id]
+					@competition = Competition.find params[:competition_id]
+
+					if @competition
+						@team.records.in(match_id: @competition.matches.map { |match| match.id }).to_json
+					else
+						[404, ErrorFormatter.format(could_not_find(params[:competition_id], "id", "competition"))]
+					end
+				else
+					@team.records.to_json
+				end
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:number], "number"))]
+			end
+		end
+
+		def self.matches(params)
+			@team = Team.find_by number: params[:number]
+
+			if @team
+				# Ensure that the competition ID is valid.
+				if params[:competition_id]
+					@competition = Competition.find params[:competition_id]
+
+					return [404, ErrorFormatter.format(could_not_find(params[:competition_id], "id", "competition"))] if @competition.nil?
+				end
+
+				@team.matches(params[:competition_id]).to_json
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:number], "number"))]
+			end
+		end
+
+		def self.competitions(params)
+			@team = Team.find_by number: params[:number]
+
+			if @team
+				@team.competitions.to_json
+			else
+				[404, ErrorFormatter.format(could_not_find(params[:number], "number"))]
+			end
+		end
+	end
+end

data/lib/frecon/controllers.rb

@@ -0,0 +1,13 @@
+# Libraries that all controllers require.
+require "json"
+require "frecon/error_formatter"
+
+require "frecon/controller"
+
+require "frecon/controllers/competitions_controller"
+require "frecon/controllers/dump_controller"
+require "frecon/controllers/matches_controller"
+require "frecon/controllers/participations_controller"
+require "frecon/controllers/records_controller"
+require "frecon/controllers/robots_controller"
+require "frecon/controllers/teams_controller"

data/lib/frecon/database.rb

@@ -0,0 +1,18 @@
+require "logger"
+require "mongoid"
+
+require "frecon/models"
+
+module FReCon
+	class Database
+		def self.setup()
+			Mongoid.load!(File.join(File.dirname(__FILE__), "mongoid.yml"), ENVIRONMENT)
+
+			Mongoid.logger.level = Logger::DEBUG
+			Mongoid.logger = Logger.new($stdout)
+
+			Moped.logger.level = Logger::DEBUG
+			Moped.logger = Logger.new($stdout)
+		end
+	end
+end

data/lib/frecon/error_formatter.rb

@@ -0,0 +1,14 @@
+require "json"
+
+module FReCon
+	class ErrorFormatter
+		def self.format(message)
+			case message
+			when String
+				JSON.generate({ errors: [ message ] })
+			when Array
+				JSON.generate({ errors: message })
+			end
+		end
+	end
+end

data/lib/frecon/match_number.rb

@@ -0,0 +1,194 @@
+require "frecon/base"
+
+module FReCon
+	class MatchNumber
+		POSSIBLE_TYPES = [:practice, :qualification, :quarterfinal, :semifinal, :final]
+		ELIMINATION_TYPES = [:quarterfinal, :semifinal, :final]
+
+		attr_reader :number, :round
+
+		# MongoDB compatibility methods.
+		def self.demongoize(object)
+			# `object' should *always* be a string (since MatchNumber#mongoize returns a
+			# String which is what is stored in the database)
+			raise ArgumentError, "`object' must be a String" unless object.is_a?(String)
+
+			MatchNumber.new(object)
+		end
+
+		def self.mongoize(object)
+			case object
+			when MatchNumber
+				object.mongoize
+			when String, Hash
+				MatchNumber.new(object).mongoize
+			else
+				object
+			end
+		end
+
+		def self.evolve(object)
+			case object
+			when MatchNumber
+				object.mongoize
+			when String, Hash
+				MatchNumber.new(object).mongoize
+			else
+				object
+			end
+		end
+
+		def mongoize
+			to_s
+		end
+
+		def initialize(args)
+			if args.is_a?(String)
+				# Match `args' against the regular expression, described below.
+				#
+				# This regular expression matches all values where the first group of
+				# characters is one of either [ "p", "q", "qf", "sf", "f" ], which is
+				# parsed as the "type" of the match. This is followed by an "m" and a
+				# group of digits, which is parsed as the "number" of the match.
+				#
+				# In addition, one can specify a "round number" following the first group
+				# of characters such as in eliminations and finals. Often times, there
+				# are multiple so-called "rounds" in eliminations, and so the system will
+				# optionally capture that round.
+				#
+				# Also, one can specify a "replay number" following the match number.
+				# this is done by appending "r" and a group of digits which is the replay
+				# number.
+				#
+				# Below are listed the match groups and what they are:
+				#
+				# 1: Match type
+				# 2: Round number (optional)
+				# 3: Match number
+				# 4: Replay string (optional)
+				# 5: Replay number (required if #4 is supplied)
+				#
+				# This behavior may change in the future.
+				match_data = args.match(/(p|q|qf|sf|f)([\d]+)?m([\d]+)(r)?([\d]+)?/i)
+
+				# Whine if we don't have a match (string is incorrectly formatted)
+				raise ArgumentError, "string is improperly formatted" unless match_data
+
+				# Check and set required stuff first, everything else later.
+
+				# Whine if we don't have a match type
+				raise ArgumentError, "match type must be supplied" unless match_data[1]
+
+				# Parse the match type string
+				@type = case match_data[1].downcase
+				        when "p"
+					        :practice
+				        when "q"
+					        :qualification
+				        when "qf"
+					        :quarterfinal
+				        when "sf"
+					        :semifinal
+				        when "f"
+					        :final
+				        else
+					        raise ArgumentError, "match type must be in [\"p\", \"q\", \"qf\", \"sf\", \"f\"]"
+				        end
+
+				# Whine if we don't have a match number
+				raise ArgumentError, "match number must be supplied" unless match_data[3]
+
+				# Parse the match number
+				@number = match_data[3].to_i
+				raise ArgumentError, "match number must be greater than 0" unless @number > 0
+
+				# Parse the round number, if it is present
+				if match_data[2]
+					@round = match_data[2].to_i
+					raise ArgumentError, "round number must be greater than 0" unless @round > 0
+				end
+
+				# Parse replay match group, store replay number if present.
+				@replay_number = match_data[5].to_i if match_data[4] == "r"
+			elsif args.is_a?(Hash)
+				# type (Symbol or String)
+				# number (Integer)
+				# round (Integer), optional
+				# replay_number (Integer), optional
+
+				raise TypeError, "type must be a Symbol or String" unless args[:type].is_a?(Symbol) || args[:type].is_a?(String)
+				raise ArgumentError, "type must be in #{POSSIBLE_TYPES.inspect}" unless POSSIBLE_TYPES.include?(args[:type].to_sym)
+
+				@type = args[:type].to_sym
+
+				raise TypeError, "match number must be an Integer" unless args[:number].is_an?(Integer)
+				raise ArgumentError, "match number must be greater than 0" unless args[:number] > 0
+
+				@number = args[:number]
+
+				if args[:round]
+					raise TypeError, "round number must be an Integer" unless args[:round].is_an?(Integer)
+					raise ArgumentError, "round number must be greater than 0" unless args[:round] > 0
+
+					@round = args[:round]
+				end
+
+				if args[:replay_number]
+					raise TypeError, "replay number must be an Integer" unless args[:replay_number].is_an?(Integer)
+					raise ArgumentError, "replay number must be greater than 0" unless args[:replay_number] > 0
+
+					@replay_number = args[:replay_number]
+				end
+			else
+				raise TypeError, "argument must be a String or Hash"
+			end
+		end
+
+		def to_s
+			type_string = case @type
+			              when :practice
+				              "p"
+			              when :qualification
+				              "q"
+			              when :quarterfinal
+				              "qf"
+			              when :semifinal
+				              "sf"
+			              when :final
+				              "f"
+			              end
+			match_string = "m#{@number}"
+			replay_string = "r#{@replay_number}" if replay?
+
+			"#{type_string}#{@round}#{match_string}#{replay_string}"
+		end
+
+		def replay?
+			!@replay_number.nil? && @replay_number > 0
+		end
+
+		def practice?
+			@type == :practice
+		end
+
+		def qualification?
+			@type == :qualification
+		end
+
+		def quarterfinal?
+			@type == :quarterfinal
+		end
+
+		def semifinal?
+			@type == :semifinal
+		end
+
+		def final?
+			@type == :final
+		end
+
+		def elimination?
+			ELIMINATION_TYPES.include?(@type)
+		end
+	end
+end

data/lib/frecon/model.rb

@@ -0,0 +1,13 @@
+require "mongoid"
+
+module FReCon
+	class Model
+		def self.inherited(child)
+			child.class_eval do
+				include Mongoid::Document
+				include Mongoid::Timestamps
+				include Mongoid::Attributes::Dynamic		
+			end
+		end
+	end
+end

data/lib/frecon/models/competition.rb

@@ -0,0 +1,26 @@
+require "frecon/model"
+
+module FReCon
+	class Competition < Model
+		field :location, type: String
+		field :name, type: String
+
+		has_many :matches, dependent: :destroy
+		has_many :participations, dependent: :destroy
+
+		validates :location, :name, presence: true
+		validates :name, uniqueness: true
+
+		def records
+			matches = self.matches
+
+			Record.in match_id: matches.map(&:id)
+		end
+
+		def teams
+			participations = self.participations
+
+			Team.in id: participations.map(&:team_id)
+		end
+	end
+end

data/lib/frecon/models/match.rb

@@ -0,0 +1,16 @@
+require "frecon/model"
+require "frecon/match_number"
+
+module FReCon
+	class Match < Model
+		field :number, type: MatchNumber
+
+		field :blue_score, type: Integer, default: 0
+		field :red_score, type: Integer, default: 0
+
+		belongs_to :competition
+		has_many :records, dependent: :destroy
+
+		validates :number, :competition_id, presence: true
+	end
+end

data/lib/frecon/models/participation.rb

@@ -0,0 +1,11 @@
+require "frecon/model"
+
+module FReCon
+	class Participation < Model
+		belongs_to :competition
+		belongs_to :team
+
+		validates :competition_id, :team_id, presence: true
+		validates :team_id, uniqueness: { scope: :competition_id }
+	end
+end

data/lib/frecon/models/record.rb

@@ -0,0 +1,18 @@
+require "frecon/model"
+require "frecon/position"
+
+module FReCon
+	class Record < Model
+		field :notes, type: String
+		field :position, type: Position
+
+		belongs_to :match
+		belongs_to :team
+
+		validates :position, :match_id, :team_id, presence: true
+
+		def competition
+			self.match.competition
+		end
+	end
+end

data/lib/frecon/models/robot.rb

@@ -0,0 +1,10 @@
+require "frecon/model"
+
+module FReCon
+	class Robot < Model
+		field :name, type: String
+
+		belongs_to :competition
+		belongs_to :team
+	end
+end

data/lib/frecon/models/team.rb

@@ -0,0 +1,44 @@
+require "frecon/model"
+
+module FReCon
+	class Team < Model
+		field :number, type: Integer
+
+		field :location, type: String
+		field :logo_path, type: String
+		field :name, type: String
+		
+		has_many :participations, dependent: :destroy
+		has_many :records, dependent: :destroy
+
+		validates :number, presence: true, uniqueness: true, numericality: { greater_than: 0 }
+
+		def self.number(team_number)
+			# Team.find_by number: team_number
+			find_by number: team_number
+		end
+
+		def competitions
+			Competition.in id: participations.map(&:competition_id)
+		end
+
+		# Returns all of the matches that this team has been in.
+		# Optionally, returns the matches that this team has played
+		# in a certain competition.
+		def matches(competition_id = nil)
+			matches = Match.in record_id: self.records.map(&:id)
+			matches = matches.where competition_id: competition_id unless competition_id.nil?
+
+			matches
+		end
+		
+		# alias_method works by default solely on instance
+		# methods, so change context to the metaclass of
+		# Team and do aliasing there.
+		class << self
+			alias_method :with_number, :number
+			alias_method :that_has_number, :number
+		end
+
+	end
+end

data/lib/frecon/models.rb

@@ -0,0 +1,6 @@
+require "frecon/models/competition"
+require "frecon/models/match"
+require "frecon/models/participation"
+require "frecon/models/record"
+require "frecon/models/robot"
+require "frecon/models/team"

data/lib/frecon/mongoid.yml

@@ -0,0 +1,19 @@
+development:
+  sessions:
+    default:
+      database: frecon
+      hosts:
+        - localhost:27017
+  options:
+    use_utc: true
+    raise_not_found_error: false
+
+production:
+  sessions:
+    default:
+      database: frecon
+      hosts:
+        - localhost:27017
+  options:
+    use_utc: true
+    raise_not_found_error: false

data/lib/frecon/position.rb

@@ -0,0 +1,117 @@
+require "frecon/base"
+
+module FReCon
+	class Position
+		attr_reader :alliance, :number
+
+		# MongoDB compatibility methods.
+		def self.demongoize(object)
+			# `object' should *always* be a string (since MatchNumber#mongoize returns a
+			# String which is what is stored in the database)
+			raise ArgumentError, "`object' must be a String" unless object.is_a?(String)
+
+			Position.new(object)
+		end
+
+		# Allows passing a String or Hash instead of a Position.
+		# i.e. record.position = "r3"
+		def self.mongoize(object)
+			case object
+			when Position
+				object.mongoize
+			when String
+				Position.new(object).mongoize
+			when Hash
+				Position.new(object[:alliance], object[:number]).mongoize
+			else
+				object
+			end
+		end
+
+		# Used for queries.
+		def self.evolve(object)
+			case object
+			when Position
+				object.mongoize
+			when String
+				Position.new(object).mongoize
+			when Hash
+				Position.new(object[:alliance], object[:number]).mongoize
+			else
+				object
+			end
+		end
+
+		def mongoize
+			to_s
+		end
+
+		def initialize(*args)
+			if args.length == 1
+				# Match `string' against the regular expression, described below.
+				#
+				# This regular expression matches all values for `string' where
+				# the first letter is either "r" or "b" (case-insensitive due to /i
+				# at the end of the regular expression) and the last one-or-more
+				# characters in the string are digits 0-9. Anything between those two
+				# that is either a letter or an underscore is not retained, but
+				# if other characters exist (e.g. spaces as of right now) `string'
+				# will not match.
+				#
+				# You can use any words you like if you have more than just
+				# "r<n>" or "b<n>", for example "red_2" matches just the same
+				# as "r2", or, just for fun, just the same as "royal______2".
+				#
+				# This behavior may change in the future.
+				match_data = args[0].match(/^([rb])[a-z\_]*([0-9]+)/i)
+
+				# Note: if matched at all, match_data[0] is the entire
+				# string that was matched, hence the indices that start
+				# at one.
+
+				raise ArgumentError, "string is improperly formatted" unless match_data
+
+				@alliance = case match_data[1].downcase
+				            when "b"
+					            :blue
+				            when "r"
+					            :red
+				            else
+					            raise ArgumentError, "alliance character must be in [\"b\", \"r\"]"
+				            end
+
+				position_number = match_data[2].to_i
+				raise ArgumentError, "position number must be in [1, 2, 3]" unless [1, 2, 3].include?(position_number)
+
+				@number = position_number
+			elsif args.length == 2
+				raise TypeError, "alliance must be a Symbol or String" unless args[0].is_a?(Symbol) || args[0].is_a?(String)
+				raise ArgumentError, "alliance must be in [:blue, :red]" unless [:blue, :red].include?(args[0].to_sym)
+
+				@alliance = args[0].to_sym
+
+				raise TypeError, "second argument must be an Integer" unless args[1].is_an?(Integer)
+				raise ArgumentError, "second argument must be in [1, 2, 3]" unless [1, 2, 3].include?(args[1])
+
+				@number = args[1]
+			else
+				raise ArgumentError, "wrong number of arguments (#{args.length} for [1, 2])"
+			end
+		end
+
+		def to_s
+			"#{@alliance[0]}#{@number}"
+		end
+
+		def is_blue?
+			@alliance == :blue
+		end
+
+		def is_red?
+			@alliance == :red
+		end
+
+		alias_method :was_blue?, :is_blue?
+		alias_method :was_red?, :is_red?
+	end
+end

data/lib/frecon/routes.rb

@@ -0,0 +1,119 @@
+require "frecon/controllers"
+
+module FReCon
+	module Routes
+		def self.resource_routes(base, name, controller, methods = [:create, :update, :delete, :show, :index])
+			if methods.include?(:create)
+				base.post "/#{name}" do
+					controller.create request, params
+				end
+			end
+
+			if methods.include?(:update)
+				base.put "/#{name}/:id" do
+					controller.update request, params
+				end
+			end
+
+			if methods.include?(:delete)
+				base.delete "/#{name}/:id" do
+					controller.delete params
+				end
+			end
+
+			if methods.include?(:show)
+				base.get "/#{name}/:id" do
+					controller.show params
+				end
+			end
+
+			if methods.include?(:index)
+				base.get "/#{name}" do
+					controller.index params
+				end
+			end
+		end
+		
+		def self.included(base)
+			resource_routes base, "teams", TeamsController, [:create, :index]
+
+			base.put "/teams/:number" do
+				TeamsController.update request, params
+			end
+
+			base.delete "/teams/:number" do
+				TeamsController.delete params
+			end
+
+			base.get "/teams/:number" do
+				TeamsController.show params
+			end
+
+			base.get "/teams/:number/records/?:competition_id?" do
+				TeamsController.records params
+			end
+
+			base.get "/teams/:number/matches/?:competition_id?" do
+				TeamsController.matches params
+			end
+
+			base.get "/teams/:number/competitions" do
+				TeamsController.competitions params
+			end
+
+			resource_routes base, "competitions", CompetitionsController
+
+			base.get "/competitions/:id/teams" do
+				CompetitionsController.teams params
+			end
+
+			base.get "/competitions/:id/matches" do
+				CompetitionsController.matches params
+			end
+
+			base.get "/competitions/:id/records" do
+				CompetitionsController.records params
+			end
+
+			resource_routes base, "matches", MatchesController
+
+			base.get "/matches/:id/records" do
+				MatchesController.records params
+			end
+
+			base.get "/matches/:id/competition" do
+				MatchesController.competition params
+			end
+
+			resource_routes base, "records", RecordsController
+
+			base.get "/records/:id/competition" do
+				RecordsController.competition params
+			end
+
+			resource_routes base, "robots", RobotsController
+
+			base.get "/robots/:id/competition" do
+				RobotsController.competition params
+			end
+
+			base.get "/robots/:id/team" do
+				RobotsController.team params
+			end
+
+			resource_routes base, "participations", ParticipationsController
+
+			base.get "/participations/:id/competition" do
+				ParticipationsController.competition params
+			end
+
+			base.get "/participations/:id/team" do
+				ParticipationsController.team params
+			end
+
+			base.get "/dump" do
+				DumpController.full params
+			end
+		end
+	end
+end

data/lib/frecon/server.rb

@@ -0,0 +1,23 @@
+require "sinatra/base"
+
+require "frecon/database"
+require "frecon/routes"
+require "frecon/controllers"
+
+module FReCon
+	class Server < Sinatra::Base
+		include Routes
+
+		configure do
+			Database.setup
+		end
+
+		before do
+			content_type "application/json"
+		end
+
+		def self.start
+			run!
+		end
+	end
+end

data/lib/frecon.rb

@@ -0,0 +1,5 @@
+require "frecon/base"
+
+require "frecon/database"
+require "frecon/server"
+require "frecon/console"

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: frecon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sam Craig
+- Kristofer Rye
+- Christopher Cooper
+- Sam Mercier
+- Tiger Huang
+- Vincent Mai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: thin
+  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: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A JSON API for scouting FRC competitions that manages the database for
+  the user.
+email: sammidysam@gmail.com
+executables:
+- frecon
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/frecon
+- lib/frecon.rb
+- lib/frecon/base.rb
+- lib/frecon/base/object.rb
+- lib/frecon/base/variables.rb
+- lib/frecon/console.rb
+- lib/frecon/controller.rb
+- lib/frecon/controllers.rb
+- lib/frecon/controllers/competitions_controller.rb
+- lib/frecon/controllers/dump_controller.rb
+- lib/frecon/controllers/matches_controller.rb
+- lib/frecon/controllers/participations_controller.rb
+- lib/frecon/controllers/records_controller.rb
+- lib/frecon/controllers/robots_controller.rb
+- lib/frecon/controllers/teams_controller.rb
+- lib/frecon/database.rb
+- lib/frecon/error_formatter.rb
+- lib/frecon/match_number.rb
+- lib/frecon/model.rb
+- lib/frecon/models.rb
+- lib/frecon/models/competition.rb
+- lib/frecon/models/match.rb
+- lib/frecon/models/participation.rb
+- lib/frecon/models/record.rb
+- lib/frecon/models/robot.rb
+- lib/frecon/models/team.rb
+- lib/frecon/mongoid.yml
+- lib/frecon/position.rb
+- lib/frecon/routes.rb
+- lib/frecon/server.rb
+homepage: https://github.com/scouting-project/scouting-project
+licenses: []
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A JSON API for scouting FRC competitions.
+test_files: []
+has_rdoc: