ankit 0.0.0

data/lib/ankit/event.rb

@@ -0,0 +1,62 @@
+
+require 'date'
+require 'json'
+
+module Ankit
+  class Envelope < Struct.new(:at, :round)
+    def to_json(*a)
+      { at: self.at.rfc3339, round: self.round }.to_json(*a)
+    end
+
+    def self.from_hash(hash)
+      Envelope.new(DateTime.rfc3339(hash["at"]), hash["round"])
+    end
+
+    def self.parse(text) from_hash(JSON.parse(text)); end
+    def self.fresh(round=0); self.new(DateTime.new, round); end
+  end
+
+  class Event
+    attr_reader :envelope, :values
+
+    def verb() @values["verb"]; end
+    def verb=(val) @values["verb"] = val; end
+    def name() @values["name"]; end
+    def type() @values["type"]; end
+    def maturity() @values["maturity"] || 0; end
+    def card?() type == "card"; end
+    def round() @envelope.round or 0; end
+    def next_round() round + 2**maturity; end
+
+    def initialize(env, values)
+      @envelope, @values = env, values
+    end
+
+    def ==(other)
+      @values == other.values && @envelope == other.envelope
+    end
+    
+    def to_json(*a) { envelope: @envelope, values: @values }.to_json(*a); end
+
+    def to_passed(env)
+      Event.new(env, @values.merge({ "verb" => "passed", "maturity" => maturity + 1 }))
+    end
+
+    def to_failed(env)
+      Event.new(env, @values.merge({ "verb" => "failed", "maturity" => 0 }))
+    end
+
+    def self.for_card(name, verb, env)
+      self.new(env, { "type" => "card", "verb" => verb, "name" => name, "maturity" => 0 })
+    end
+
+    def self.from_hash(hash) Event.new(Envelope.from_hash(hash["envelope"]), hash["values"]); end
+    def self.parse(text) from_hash(JSON.parse(text)); end
+  end
+
+  module EventFormatting
+    def format_as_score(event)
+      "name:#{event.name}, verb:#{event.verb}, round:#{event.round}, maturity:#{event.maturity}"
+    end
+  end
+end

data/lib/ankit/event_traversing_command.rb

@@ -0,0 +1,37 @@
+
+require 'ankit/command'
+require 'ankit/card'
+
+module Ankit
+  class EventTraversingCommand < Command
+    def each_event(name=nil, &block)
+      runtime.config.journals.each do |j|
+        open(j) do |f|
+          f.each_line do |line|
+            event = Event.parse(line)
+            block.call(event) if nil == name or event.name == name
+          end
+        end
+      end
+    end
+  end
+
+  # For Command Mixin
+  module EventTraversing
+    class << self
+      include CardNaming
+    end
+
+    def self.find_latest_event_for(runtime, path)
+      #EventTraversingCommand.new(runtime).to_enum(:each_event, to_card_name(path)).sort_by { |x| x.round }[-1]
+      find_latest_event_named(runtime, to_card_name(path))
+    end
+
+    def self.find_latest_event_named(runtime, name)
+      EventTraversingCommand.new(runtime).to_enum(:each_event, name).sort_by { |x| x.round }[-1]
+    end
+
+    def latest_event_for(path) EventTraversing.find_latest_event_for(self.runtime, path); end
+  end
+
+end

data/lib/ankit/fail_command.rb

@@ -0,0 +1,14 @@
+
+require 'ankit/card_happening_command'
+
+module Ankit
+  class FailCommand < CardHappeningCommand
+    available
+    EVENT_HAPPENING = :to_failed
+  end
+
+  module Failing
+    include CardHappening
+    def make_failed(card_name); make_happen(FailCommand::EVENT_HAPPENING, card_name); end
+  end
+end

data/lib/ankit/find_command.rb

@@ -0,0 +1,38 @@
+
+require 'ankit/card'
+require 'ankit/command'
+require 'ankit/find_command'
+
+module Ankit
+  class FindCommand < Command
+    include CardNaming
+    available
+
+    def execute()
+      each_path { |f| runtime.stdout.print("#{f}\n") }
+    end
+
+    def each_path(&block)
+      names.each do |n|
+        found = path_for(n)
+        block.call(found) if found
+      end
+    end
+
+    def path_for(name)
+      found_in = runtime.config.card_search_paths.find do |p|
+        File.file?(to_card_path(p, name))
+      end
+
+      found_in ? to_card_path(found_in, name) : nil
+    end
+
+    def names; args; end
+  end
+
+  module Finding
+    def find_paths(runtime, names)
+      FindCommand.new(runtime, names).to_enum(:each_path).to_a
+    end
+  end
+end

data/lib/ankit/hello_command.rb

@@ -0,0 +1,22 @@
+
+require 'ankit/command'
+
+module Ankit
+  class HelloCommand < Command
+    available
+
+    def execute()
+      indent = "  "
+      runtime.stdout.print("\n")
+      runtime.stdout.print(indent, "repo: #{runtime.config.repo}\n")
+      runtime.stdout.print(indent, "primary: #{runtime.config.primary_journal}\n")
+      runtime.stdout.print(indent, "location: #{runtime.config.location}\n")
+
+      runtime.config.card_search_paths.each do |p|
+        runtime.stdout.print(indent, "card_search_paths: #{p}\n")
+      end
+
+      runtime.stdout.print("\n")
+    end
+  end
+end

data/lib/ankit/list_command.rb

@@ -0,0 +1,26 @@
+
+require 'ankit/card'
+require 'ankit/command'
+
+module Ankit
+  class ListCommand < Command
+    include CardNaming
+    available
+
+    def execute()
+      each_card { |f| runtime.stdout.print("#{f}\n") }
+    end
+
+    def each_card(&block)
+      runtime.config.card_search_paths.each do |p|
+        Dir.glob(card_wildcard_for(p)).each do |f|
+          block.call(f)
+        end
+      end
+    end
+
+    def each_card_name(&block)
+      each_card { |path| block.call(to_card_name(path)) }
+    end
+  end
+end

data/lib/ankit/name_command.rb

@@ -0,0 +1,16 @@
+
+require 'ankit/text_reading_command'
+
+module Ankit
+  class NameCommand < TextReadingCommand
+    available
+    define_options { |s, o| superclass.option_spec.call(s, o) }
+
+    def execute()
+      validate_options
+      each_text do |text|
+        runtime.stdout.print("#{Card.parse(text).name}\n")
+      end
+    end
+  end
+end

data/lib/ankit/pass_command.rb

@@ -0,0 +1,9 @@
+
+require 'ankit/card_happening_command'
+
+module Ankit
+  class PassCommand < CardHappeningCommand
+    available
+    EVENT_HAPPENING = :to_passed
+  end
+end

data/lib/ankit/round_command.rb

@@ -0,0 +1,31 @@
+
+require 'ankit/card'
+#require 'ankit/event_traversing_command'
+require 'ankit/coming_command'
+
+module Ankit
+  class RoundCommand < Command
+    available
+
+    def execute()
+      runtime.stdout.print("#{last_round} #{next_round}\n")
+    end
+
+    def next_round
+      found = Coming.existing_events(runtime).first
+      found ? found.next_round : 0
+    end
+
+    def last_round
+      found = Coming.existing_events(runtime).max_by(&:round)
+      found ? found.round : 0
+    end
+  end
+
+  module RoundCounting
+    def last_round; @last_round ||= RoundCommand.new(self.runtime).last_round; end
+    def next_round; @next_round ||= RoundCommand.new(self.runtime).next_round; end
+    def latest_round; last_round + 1; end
+    def round_proceeded; @last_round = @next_round = nil; end
+  end
+end

data/lib/ankit/runtime.rb

@@ -0,0 +1,151 @@
+
+require 'optparse'
+require 'fileutils'
+require 'highline'
+require 'ankit/command'
+require 'ankit/add_command'
+require 'ankit/challenge_command'
+require 'ankit/coming_command'
+require 'ankit/fail_command'
+require 'ankit/find_command'
+require 'ankit/hello_command'
+require 'ankit/list_command'
+require 'ankit/name_command'
+require 'ankit/pass_command'
+require 'ankit/round_command'
+require 'ankit/score_command'
+
+module Ankit
+
+  class Config
+    DEFAULT_PATH = File.expand_path("~/.ankit")
+
+    attr_writer :repo, :location, :card_paths
+
+    def repo; @repo ||= File.expand_path("~/.ankit.d"); end
+    def location; @location ||= `hostname`.strip; end
+    def card_paths; @card_paths ||= [File.join(repo, "cards")]; end
+
+    # Computed parameters
+    def primary_journal
+      File.join(repo, "#{location}.journal")
+    end
+
+    def journals
+      Dir.glob(File.join(repo, "*.journal")).sort
+    end
+
+    def card_search_paths
+      paths = self.card_paths.dup
+      self.card_paths.each do |path|
+        Dir.glob(File.join(path, "*")).each do |f|
+          paths.push(f) if File.directory?(f)
+        end
+      end
+
+      paths.sort
+    end
+
+
+    def self.open(path)
+      config = self.new
+      config.instance_eval(File.open(path){ |f| f.read })
+      config
+    end
+
+    def self.prepare_default
+      FileUtils.touch([DEFAULT_PATH]) # TODO: Give same example settings.
+      plain = Config.open(DEFAULT_PATH)
+      (plain.card_paths + [plain.repo]).each { |p| FileUtils.mkdir_p(p) }
+      FileUtils.touch([plain.primary_journal])
+      STDOUT.print("Prepared the default setting. You can edit #{DEFAULT_PATH}\n")
+    end
+  end
+
+  class Runtime
+    attr_writer :line, :stdin, :stdout, :stderr
+    attr_reader :config
+
+    def line; @line ||= HighLine.new; end
+    def stdin; @stdin ||= STDIN; end
+    def stdout; @stdout ||= STDOUT; end
+    def stderr; @stderr ||= STDERR; end
+
+    def self.split_subcommand(args)
+      names = Command.by_name.keys
+      i = args.find_index { |a| names.include?(a) }
+      unless i.nil?
+        { global: args[0 ... i], subcommand: args[i .. -1] }
+      else
+        { global: [], subcommand: [] }
+      end
+    end
+
+    def self.parse_options(args)
+      options = {}
+      OptionParser.new do |spec|
+        spec.on("-c", "--config FILE", "Specifies config file") { |file| options[:config] = file }
+      end.parse(args)
+
+      options[:noconf]   = options[:config].nil?
+      options[:config] ||= Config::DEFAULT_PATH
+      options
+    end
+
+    def self.setup(args)
+      options = self.parse_options(args)
+      Config.prepare_default if options[:noconf] and not File.exist?(Config::DEFAULT_PATH)
+      r = self.new(Config.open(options[:config]))
+    end
+    
+    def self.run(args)
+      splitted = self.split_subcommand(args)
+      r = self.setup(splitted[:global])
+      if splitted[:subcommand].empty?
+        # TODO: show help
+      else
+        r.dispatch(splitted[:subcommand])
+      end
+    end
+    
+    def initialize(config)
+      @config = config
+    end
+
+    def make_command(args)
+      name = args.shift
+      Command.by_name[name].new(self, args)
+    end
+
+    def dispatch(args)
+      command = make_command(args)
+      command.execute()
+      command
+    end
+
+    # To encourage one-liner
+    def dispatch_then(args)
+      dispatch(args)
+      self
+    end
+
+    def supress_io
+      saved = [@stdin, @stdout, @stderr]
+      ["stdin=", "stdout=", "stderr="].each { |m| self.send(m, StringIO.new) }
+      saved
+    end
+
+    def unsupress_io(saved)
+      @stdin, @stdout, @stderr =  saved
+    end
+
+    def with_supressing_io(&block)
+      saved = supress_io
+      begin
+        block.call
+      ensure
+        unsupress_io(saved)
+      end
+    end
+  end
+end

data/lib/ankit/score_command.rb

@@ -0,0 +1,24 @@
+
+require 'ankit/card'
+require 'ankit/event'
+require 'ankit/event_traversing_command'
+
+module Ankit
+  class ScoreCommand < EventTraversingCommand
+    include CardNaming, EventFormatting
+    available
+
+    define_options do |spec, options| 
+      spec.on("-l", "--last") { options[:last] = true }
+    end
+
+    def execute()
+      args.each do |a|
+        list = to_enum(:each_event, to_card_name(a)).to_a
+        (options[:last] ? list.sort_by(&:round).reverse.take(1) : list).each do |e|
+          runtime.stdout.print("#{format_as_score(e)}\n")
+        end
+      end
+    end
+  end
+end

data/lib/ankit/text_reading_command.rb

@@ -0,0 +1,23 @@
+
+require 'ankit/command'
+
+module Ankit
+  class TextReadingCommand < Command
+    define_options do |spec, options|
+      spec.on("-i", "--stdin") { options[:stdin] = true }
+    end
+
+    def each_text(&block)
+      if options[:stdin]
+        block.call(runtime.stdin.read)
+      else
+        args.each { |name| open(name) { |f| block.call(f.read) } }
+      end
+    end
+
+    def validate_options
+      raise BadOptions, "--stdin cannot have any fileame" if options[:stdin] and not args.empty?
+      raise BadOptions, "need a fileame" if not options[:stdin] and args.empty?
+    end
+  end
+end

data/lib/ankit.rb

@@ -0,0 +1,3 @@
+
+require 'ankit/runtime'
+

data/test/card_test.rb

@@ -0,0 +1,92 @@
+
+require 'ankit/card'
+require 'test/unit'
+
+class CardTest < Test::Unit::TestCase
+  include Ankit
+
+  def test_parse_empty
+    actual = Card.parse(
+"""
+
+  
+""")
+    assert_nil(actual)
+  end
+
+  def test_parse_empty_comments
+    actual = Card.parse(
+"""
+#
+#
+""")
+    assert_nil(actual)
+  end
+
+  def test_parse_hello
+    actual = Card.parse(
+"""
+O: Hello, how are you?
+T: Konichiwa, Genki? 
+""")
+
+    assert_equal("Konichiwa, Genki?", actual.translation)
+    assert_equal("Hello, how are you?", actual.original)
+  end
+
+  def test_name_plain
+    actual = Card.parse(
+"""
+O: Hello, how are you?
+T: Konichiwa, Genki? 
+""")
+    assert_equal("hello-how-are-you", actual.name)
+  end
+
+  def test_name_with_a_bracket
+    actual = Card.parse(
+"""
+O: [Hello], How are you?
+T: Konichiwa, Genki? 
+""")
+    assert_equal("hello-how-are-you", actual.name)
+  end
+
+  def test_name_with_brackets
+    actual = Card.parse(
+"""
+O: Hello, [How is] your project [going]?
+T: Konichiwa, Genki? 
+""")
+    assert_equal("hello-how-is-your-project-going", actual.name)
+  end
+
+  def test_guess_id_with_conflict
+    # XXX: will tackle later
+  end
+
+  def test_plain_original
+    assert_equal(Card.new(o: "Hello").plain_original, "Hello")
+    assert_equal(Card.new(o: "Hello, [World].").plain_original, "Hello, World.")
+  end
+
+  def test_match_hello
+    target = Card.new(o: "Hello")
+    assert( target.match?("Hello"))
+    assert_equal(:wrong, target.match?("Bye"))
+  end
+
+  def test_match_bracket
+    target = Card.new(o: "Hello, [World].")
+    assert_equal(:match, target.match?("Hello, World."))
+  end
+
+  def test_match_typo
+    target = Card.new(o: "Hello, [World].")
+    assert_equal(:typo, target.match?("Hallo, World."))
+    assert_equal(:typo, target.match?("Halo, World."))
+    assert_equal(:typo, target.match?("Hello, World!"))
+    assert_equal(:typo, target.match?("World!"))
+    assert_equal(:wrong, target.match?(""))
+  end
+end