clicoder 0.0.1

data/lib/clicoder/cli.rb

@@ -0,0 +1,190 @@
+require 'thor'
+require 'thor/group'
+require 'launchy'
+
+require 'clicoder/judge'
+require 'clicoder/site_base'
+require 'clicoder/sites/sample_site'
+require 'clicoder/sites/aoj'
+require 'clicoder/sites/atcoder'
+
+module Clicoder
+  class Starter < Thor
+    desc "sample_site", "Prepare directory to deal with new problem from SampleSite"
+    def sample_site
+      sample_site = SampleSite.new
+      start_with(sample_site)
+    end
+
+    desc "aoj PROBLEM_NUMBER", "Prepare directory to deal with new problem from AOJ"
+    def aoj(problem_number)
+      aoj = AOJ.new(problem_number)
+      start_with(aoj)
+    end
+
+    desc "atcoder CONTEST_ID PROBLEM_NUMBER", "Prepare directory to deal with new problem from AtCoder"
+    def atcoder(contest_id, problem_number)
+      atcoder = AtCoder.new(contest_id, problem_number)
+      start_with(atcoder)
+    end
+
+    no_commands do
+      def start_with(site)
+        site.start
+        puts "created directory #{site.working_directory}"
+        system("cd #{site.working_directory} && git init")
+      end
+    end
+  end
+
+  class CLI < Thor
+    desc "all", "build, execute, and judge"
+    def all
+      invoke :build
+      invoke :execute
+      invoke :judge
+    end
+
+    desc "build", "Build your program using `make build`"
+    def build
+      load_local_config
+      system('make build')
+    end
+
+    desc "execute", "Execute your program using `make execute`"
+    def execute
+      load_local_config
+      Dir.glob("#{INPUTS_DIRNAME}/*.txt").each do |input|
+        puts "executing #{input}"
+        FileUtils.cp(input, TEMP_INPUT_FILENAME)
+        system("make execute")
+        FileUtils.cp(TEMP_OUTPUT_FILENAME, "#{MY_OUTPUTS_DIRNAME}/#{File.basename(input)}")
+      end
+      FileUtils.rm([TEMP_INPUT_FILENAME, TEMP_OUTPUT_FILENAME])
+    end
+
+    desc "judge", "Judge your outputs"
+    method_option :decimal, type: :numeric, aliases: '-d', desc: 'Decimal position of allowed absolute error'
+    def judge
+      load_local_config
+      accepted = true
+      judge = Judge.new(options)
+      Dir.glob("#{OUTPUTS_DIRNAME}/*.txt").each do |output|
+        puts "judging #{output}"
+        my_output =  "#{MY_OUTPUTS_DIRNAME}/#{File.basename(output)}"
+        if File.exists?(my_output)
+          unless judge.judge(output, my_output)
+            puts '! Wrong Answer'
+            system("diff -y #{output} #{my_output}")
+            accepted = false
+          end
+        else
+          puts "! #{my_output} does not exist"
+          accepted = false
+        end
+      end
+      if accepted
+        puts "Correct Answer"
+      else
+        puts "Wrong Answer"
+      end
+    end
+
+    desc "submit", "Submit your program"
+    def submit
+      load_local_config
+      site = get_site
+      if site.submit
+        puts "Submission Succeeded."
+        site.open_submission
+      else
+        puts "Submission Failed."
+        exit 1
+      end
+    end
+
+    desc "add_test", "Add new test case"
+    def add_test
+      load_local_config
+      test_count = Dir.glob("#{INPUTS_DIRNAME}/*.txt").count
+      input_file = "#{INPUTS_DIRNAME}/#{test_count}.txt"
+      output_file = "#{OUTPUTS_DIRNAME}/#{test_count}.txt"
+      puts 'Input:'
+      system("cat > #{input_file}")
+      puts 'Output:'
+      system("cat > #{output_file}")
+    end
+
+    desc "download", "Download description, inputs and outputs"
+    def download
+      load_local_config
+      site = get_site
+      # TODO: this is not beautiful
+      Dir.chdir('..') do
+        site.download_description
+        site.download_inputs
+        site.download_outputs
+      end
+    end
+
+    desc "browse", "Open problem page with the browser"
+    def browse
+      load_local_config
+      site = get_site
+      Launchy.open(site.problem_url)
+    end
+
+    no_commands do
+      def load_local_config
+        unless File.exists?('.config.yml')
+          puts 'It seems you are not in probelm directory'
+          exit 1
+        end
+        @local_config = YAML::load_file('.config.yml')
+      end
+
+      def get_site
+        SiteBase.new_with_config(@local_config)
+      end
+    end
+    register Starter, 'new', 'new <command>', 'start a new problem'
+  end
+
+  # Use aruba in-process
+  # https://github.com/cucumber/aruba
+  # https://github.com/erikhuda/thor/wiki/Integrating-with-Aruba-In-Process-Runs
+  class ArubaCLI
+    def initialize(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel)
+      @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+    end
+
+    def execute!
+      exit_code = begin
+        # Thor accesses these streams directly rather than letting them be injected, so we replace them...
+        $stderr = @stderr
+        $stdin = @stdin
+        $stdout = @stdout
+
+        # Run our normal Thor app the way we know and love.
+        CLI.start(@argv)
+
+        # Thor::Base#start does not have a return value, assume success if no exception is raised.
+        0
+      rescue Exception => e
+        # Proxy any exception that comes out of Thor itself back to stderr
+        $stderr.write(e.message + "\n")
+
+        # Exit with a failure code.
+        1
+      ensure
+        # ...then we put them back.
+        $stderr = STDERR
+        $stdin = STDERR
+        $stdout = STDERR
+      end
+
+      # Proxy our exit code back to the injected kernel.
+      @kernel.exit(exit_code)
+    end
+  end
+end

data/lib/clicoder/config.rb

@@ -0,0 +1,50 @@
+require 'clicoder'
+
+module Clicoder
+  class Config
+    attr_accessor :global, :local
+
+    def initialize
+      global_config_file = "#{global_config_dir}/config.yml"
+      @global = File.exists?(global_config_file) ? YAML::load_file(global_config_file) : {}
+      local_config_file = '.config.yml'
+      @local = File.exists?(local_config_file) ? YAML::load_file(local_config_file) : {}
+    end
+
+    # NOTE: This is not a class variable in order to evaluate stubbed ENV['HOME'] on each RSpec run
+    def global_config_dir
+      @global_config_dir ||= "#{ENV['HOME']}/.clicoder.d"
+    end
+
+    def asset(asset_name)
+      site_name = get('site')
+      file_name = get(site_name, asset_name)
+      if file_name.empty?
+        file_name = get('default', asset_name)
+      end
+
+      unless file_name.empty?
+        return File.expand_path(file_name, global_config_dir)
+      else
+        return ''
+      end
+    end
+
+    def merged_config
+      @merged_config ||= global.merge(local)
+    end
+
+    def get(*keys)
+      conf = merged_config
+      begin
+        keys.each do |key|
+          conf = conf[key]
+        end
+        return conf.nil? ? '' : conf
+      rescue
+        return ''
+      end
+    end
+
+  end
+end

data/lib/clicoder/judge.rb

@@ -0,0 +1,30 @@
+module Clicoder
+  class Judge
+    def initialize(options)
+      @options = options
+    end
+
+    def judge(file1, file2)
+      if @options[:decimal]
+        float_judge(file1, file2, 10**(- @options[:decimal]))
+      else
+        diff_judge(file1, file2)
+      end
+    end
+
+    def diff_judge(file1, file2)
+      File.read(file1) == File.read(file2)
+    end
+
+    def float_judge(file1, file2, absolute_error)
+      lines1 = File.read(file1).split($/).map(&:strip)
+      floats1 = lines1.map{ |line| line.split(/\s+/).map(&:to_f) }.flatten
+      lines2 = File.read(file2).split($/).map(&:strip)
+      floats2 = lines2.map{ |line| line.split(/\s+/).map(&:to_f) }.flatten
+      floats1.zip(floats2).each do |float1, float2|
+        return false if (float1 - float2).abs >= absolute_error
+      end
+      true
+    end
+  end
+end

data/lib/clicoder/site_base.rb

@@ -0,0 +1,131 @@
+require 'open-uri'
+require 'nokogiri'
+require 'yaml'
+require 'net/http'
+require 'abstract_method'
+require 'reverse_markdown'
+
+require 'clicoder'
+require 'clicoder/config'
+
+module Clicoder
+  class SiteBase
+    include Helper
+
+    # Parameters
+    abstract_method :site_name
+    abstract_method :problem_url
+    abstract_method :description_xpath
+    abstract_method :inputs_xpath
+    abstract_method :outputs_xpath
+    abstract_method :working_directory
+
+    # Operations
+    abstract_method :login
+    abstract_method :submit
+    abstract_method :open_submission
+
+    def self.new_with_config(config)
+      case config['site']
+      when 'sample_site'
+        SampleSite.new
+      when 'aoj'
+        AOJ.new(config['problem_number'])
+      when 'atcoder'
+        AtCoder.new(config['contest_id'], config['problem_number'])
+      end
+    end
+
+    def start
+      prepare_directories
+      login do
+        download_description
+        download_inputs
+        download_outputs
+      end
+      copy_template
+      copy_makefile
+      store_local_config
+    end
+
+    def prepare_directories
+      FileUtils.mkdir_p(working_directory)
+      Dir.chdir(working_directory) do
+        FileUtils.mkdir_p(INPUTS_DIRNAME)
+        FileUtils.mkdir_p(OUTPUTS_DIRNAME)
+        FileUtils.mkdir_p(MY_OUTPUTS_DIRNAME)
+      end
+    end
+
+    def download_description
+      Dir.chdir(working_directory) do
+        File.open('description.md', 'w') do |f|
+          f.write(ReverseMarkdown.parse(fetch_description))
+        end
+      end
+    end
+
+    def download_inputs
+      Dir.chdir("#{working_directory}/#{INPUTS_DIRNAME}") do
+        fetch_inputs.each_with_index do |input, i|
+          File.open("#{i}.txt", 'w') do |f|
+            f.write(input.strip + "\n")
+          end
+        end
+      end
+    end
+
+    def download_outputs
+      Dir.chdir("#{working_directory}/#{OUTPUTS_DIRNAME}") do
+        fetch_outputs.each_with_index do |output, i|
+          File.open("#{i}.txt", 'w') do |f|
+            f.write(output.strip + "\n")
+          end
+        end
+      end
+    end
+
+    def copy_template
+      template_file = config.asset('template')
+      return unless File.file?(template_file)
+      ext = File.extname(template_file)
+      FileUtils.cp(template_file, "#{working_directory}/main#{ext}")
+    end
+
+    def copy_makefile
+      makefile = config.asset('makefile')
+      return unless File.file?(makefile)
+      ext = File.extname(makefile)
+      FileUtils.cp(makefile, "#{working_directory}/Makefile")
+    end
+
+    def fetch_description
+      xml_document.at_xpath(description_xpath)
+    end
+
+    def fetch_inputs
+      input_nodes = xml_document.xpath(inputs_xpath)
+      input_nodes.map(&:text)
+    end
+
+    def fetch_outputs
+      outputs_nodes = xml_document.xpath(outputs_xpath)
+      outputs_nodes.map(&:text)
+    end
+
+    def store_local_config
+      config.local['site'] = site_name
+      File.open("#{working_directory}/.config.yml", 'w') do |f|
+        f.write(config.local.to_yaml)
+      end
+    end
+
+    def xml_document
+      @xml_document ||= Nokogiri::HTML(open(problem_url))
+    end
+
+    def config
+      @config ||= Config.new
+    end
+  end
+end

data/lib/clicoder/sites/aoj.rb

@@ -0,0 +1,59 @@
+require 'clicoder/site_base'
+require 'clicoder/config'
+
+module Clicoder
+  class AOJ < SiteBase
+
+    def initialize(problem_number)
+      config.local['problem_number'] = problem_number
+      @problem_id = "%04d" % problem_number
+    end
+
+    def submit
+      submit_url = 'http://judge.u-aizu.ac.jp/onlinejudge/servlet/Submit'
+      post_params = {
+        userID: config.get('aoj', 'user_id'),
+        password: config.get('aoj', 'password'),
+        problemNO: @problem_id,
+        language: ext_to_language_name(File.extname(detect_main)),
+        sourceCode: File.read(detect_main),
+        submit: 'Send'
+      }
+      response = Net::HTTP.post_form(URI(submit_url), post_params)
+      return response.body !~ /UserID or Password is Wrong/
+    end
+
+    def open_submission
+      Launchy.open('http://judge.u-aizu.ac.jp/onlinejudge/status.jsp')
+    end
+
+    def login
+      # no need to login for now
+      yield
+    end
+
+    def site_name
+      'aoj'
+    end
+
+    def problem_url
+      "http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=#{@problem_id}"
+    end
+
+    def description_xpath
+      '//div[@class="description"]'
+    end
+
+    def inputs_xpath
+      '//*[self::pre or self::div/pre][preceding-sibling::*[self::h2 or self::h3][1][text()="Sample Input"]]'
+    end
+
+    def outputs_xpath
+      '//*[self::pre or self::div/pre][preceding-sibling::*[self::h2 or self::h3][text()="Output for the Sample Input"]]'
+    end
+
+    def working_directory
+      @problem_id
+    end
+  end
+end

data/lib/clicoder/sites/atcoder.rb

@@ -0,0 +1,66 @@
+require 'clicoder/site_base'
+require 'clicoder/config'
+
+require 'mechanize'
+
+module Clicoder
+  class AtCoder < SiteBase
+
+    def initialize(contest_id, problem_number)
+      config.local['contest_id'] = contest_id
+      config.local['problem_number'] = problem_number
+      @contest_id = contest_id
+      @problem_id = "#{@contest_id}_#{problem_number}"
+    end
+
+    def submit
+      login do |mechanize, contest_page|
+        problem_page = mechanize.get(problem_url)
+        submit_page = problem_page.link_with(href: /submit/).click
+        submit_page.form_with(action: /submit/) do |f|
+          f.field_with(name: 'source_code').value = File.read(detect_main)
+        end.click_button
+      end
+    end
+
+    def open_submission
+      Launchy.open("http://#{@contest_id}.contest.atcoder.jp/submissions/me")
+    end
+
+    def login
+      Mechanize.start do |m|
+        login_page = m.get("http://#{@contest_id}.contest.atcoder.jp/login")
+        contest_home_page = login_page.form_with(action: '/login') do |f|
+          f.field_with(name: 'name').value = config.get('atcoder', 'user_id')
+          f.field_with(name: 'password').value = config.get('atcoder', 'password')
+        end.click_button
+
+        yield m, contest_home_page
+      end
+    end
+
+    def site_name
+      'atcoder'
+    end
+
+    def problem_url
+      "http://#{@contest_id}.contest.atcoder.jp/tasks/#{@problem_id}"
+    end
+
+    def description_xpath
+      '//div[@id="task-statement"]'
+    end
+
+    def inputs_xpath
+      '//pre[preceding-sibling::h3[1][contains(text(), "入力例")]]'
+    end
+
+    def outputs_xpath
+      '//pre[preceding-sibling::h3[1][contains(text(), "出力例")]]'
+    end
+
+    def working_directory
+      @problem_id
+    end
+  end
+end

data/lib/clicoder/sites/sample_site.rb

@@ -0,0 +1,52 @@
+require 'clicoder/site_base'
+require 'clicoder/config'
+
+require 'net/http'
+require 'launchy'
+
+module Clicoder
+  class SampleSite < SiteBase
+
+    def submit
+      submit_url = 'http://samplesite.com/submit'
+      post_params = {
+        user_id: config.get('sample_site', 'user_id'),
+        password: config.get('sample_site', 'password'),
+      }
+      response = Net::HTTP.post_form(URI(submit_url), post_params)
+      return response.body =~ /Success/
+    end
+
+    def open_submission
+      Launchy.open('http://samplesite.com/submissions')
+    end
+
+    def login
+      yield
+    end
+
+    def site_name
+      'sample_site'
+    end
+
+    def problem_url
+      "#{GEM_ROOT}/fixtures/sample_problem.html"
+    end
+
+    def description_xpath
+      '//div[@id="description"]'
+    end
+
+    def inputs_xpath
+      '//div[@id="inputs"]/pre'
+    end
+
+    def outputs_xpath
+      '//div[@id="outputs"]/pre'
+    end
+
+    def working_directory
+      'working_directory'
+    end
+  end
+end

data/lib/clicoder/version.rb

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

data/lib/clicoder.rb

@@ -0,0 +1,32 @@
+require "clicoder/version"
+
+module Clicoder
+  GEM_ROOT = Gem::Specification.find_by_name('clicoder').gem_dir
+
+  INPUTS_DIRNAME = 'inputs'
+  OUTPUTS_DIRNAME = 'outputs'
+  MY_OUTPUTS_DIRNAME = 'my_outputs'
+  TEMP_INPUT_FILENAME = 'in.txt'
+  TEMP_OUTPUT_FILENAME = 'out.txt'
+
+  module Helper
+    def detect_main
+      Dir.glob('main.*').first
+    end
+
+    def ext_to_language_name(ext)
+      @map ||= {
+        cpp: 'C++',
+        cc: 'C++',
+        c: 'C',
+        java: 'JAVA',
+        cs: 'C#',
+        d: 'D',
+        rb: 'Ruby',
+        py: 'Python',
+        php: 'PHP'
+      }
+      return @map[ext.gsub(/^\./, '').to_sym]
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+require 'clicoder'
+require 'clicoder/config'
+
+module Clicoder
+  describe Config do
+    let(:config) { Config.new }
+    let(:global_config) { YAML::load_file(global_config_file) }
+    let(:global_config_dir) { "#{ENV['HOME']}/.clicoder.d" }
+    let(:global_config_file) { "#{global_config_dir}/config.yml" }
+    let(:local_config) { { 'site' => 'sample_site' } }
+    let(:local_config_file) { '.config.yml' }
+
+    before do
+      File.open(local_config_file, 'w') do |f|
+        f.write(local_config.to_yaml)
+      end
+    end
+
+    describe '.new' do
+      it 'loads global configuration from global_config_file' do
+        expect(config.global).to eql(global_config)
+      end
+
+      it 'loads local configuration from local_config_file' do
+        expect(config.local).to eql(local_config)
+      end
+    end
+
+    describe '#asset' do
+      context 'when the site specific asset is specified in the config file' do
+        it 'returns site specific template' do
+          site = local_config['site']
+          file_name = global_config[site]['template']
+          expect(config.asset('template')).to eql(File.expand_path(file_name, global_config_dir))
+        end
+      end
+
+      context 'when the site specific asset is not specified in the config file' do
+        before do
+          config.global[local_config['site']] = {}
+        end
+
+        it 'returns default template' do
+          file_name = global_config['default']['template']
+          expect(config.asset('template')).to eql(File.expand_path(file_name, global_config_dir))
+        end
+      end
+
+      context 'when nothing is specified in the config file' do
+        before do
+          config.global = {}
+        end
+
+        it 'returns empty string' do
+          expect(config.asset('template')).to eql('')
+        end
+      end
+    end
+
+    describe '#get' do
+      context 'without arguments' do
+        it 'returns config.global.merge(config.local)' do
+          expect(config.get()).to eql(config.global.merge(config.local))
+        end
+      end
+
+      context 'with arguments' do
+        context 'when config is missing' do
+          it 'returns empty string' do
+            expect(config.get('it', 'is', 'missing')).to eql('')
+          end
+        end
+
+        context 'when config is present' do
+          it 'returns the config value' do
+            expect(config.get('sample_site', 'user_id')).to eql(global_config['sample_site']['user_id'])
+          end
+        end
+      end
+    end
+  end
+end