ankit 0.0.2 → 0.0.3

data/lib/ankit/add_command.rb

@@ -14,12 +14,14 @@ module Ankit
     def execute()
       validate_options
       each_text do |text|
-        card = Card.parse(text)
-        # TODO: gaurd ovewrite
-        # TODO: guard out-of-path write
-        filename = to_card_path(dest_dir, card.name)
-        File.open(filename, "w") { |f| f.write(text) }
-        runtime.stdout.write("#{filename}\n")
+        text.split(/\n\n+/).each do |chunk|
+          card = Card.parse(chunk)
+          # TODO: gaurd ovewrite
+          # TODO: guard out-of-path write
+          filename = to_card_path(dest_dir, card.name)
+          File.open(filename, "w") { |f| f.write(text) }
+          runtime.stdout.write("#{filename}\n")
+        end
       end
     end
 

data/lib/ankit/challenge.rb

@@ -25,6 +25,8 @@ module Ankit
         HighLine.color(text, HighLine::GREEN_STYLE)
       when :wrong
         HighLine.color(text, HighLine::RED_STYLE)
+      when :fyi
+        HighLine.color(text, HighLine::DARK)
       else
         raise
       end
@@ -35,7 +37,6 @@ module Ankit
     def decorated(type)
       raise
       decorated = @text.gsub(/\[(.*?)\]/) { |t|
-        p Regexp::last_match.offset(0)
         self.class.styled_text($1, type)
       }
       decorated != @text ? decorated : self.class.styled_text(@text, type)
@@ -74,23 +75,58 @@ module Ankit
         end
       end
     end
+
+    def mixed_hilight_for_flash(wrong)
+      diff_from_original(wrong) do |ch|
+        case ch.action
+        when "="
+          StylableText.styled_text(ch.old_element, :fyi)
+        when "!", "-"
+          StylableText.styled_text(ch.old_element, :wrong) + StylableText.styled_text(ch.new_element, :correct)
+        when "+"
+          StylableText.styled_text(ch.new_element, :correct)
+        else
+          raise
+        end
+      end
+    end
   end
 
   module Challenge
     class Slot < Struct.new(:path, :rating, :event)
+      BATCH_SIZE = 10
       def maturity; self.event ? self.event.maturity : 0; end
     end
 
-    class Session < Struct.new(:runtime, :npassed, :nfailed, :mature_names)
-      def self.make(runtime)
-        self.new(runtime, 0, 0, [])
+    class Session < Struct.new(:runtime, :limit, :npassed, :nfailed, :passed_events)
+      def self.make(runtime, limit)
+        self.new(runtime, limit, 0, 0, {})
       end
 
       def summary_text
-        total = self.npassed + self.nfailed
-        return "" if 0 == total
-        "#{self.npassed}/#{total} = #{self.npassed.to_f/total.to_f}, #mature: #{mature_names.size}"
+        ""
+      end
+      
+      def passed_on(event)
+        self.passed_events[event.name] = event
+        self.npassed += 1
+      end
+
+      def failed_on(event)
+        self.nfailed += 1
+      end
+
+      def maturity_triple
+        return [0,0,0] if passed_events.empty?
+        mats = passed_events.values.map(&:maturity)
+        avg = mats.inject(0,:+)/mats.size
+        [mats.min, avg, mats.max]
       end
+
+      def reached_limit?; limit <= passed_events.size; end
+      def limit_reach; passed_events.size ;end
+      def ntotal; npassed + nfailed; end
+      def hitrate; 0 < ntotal ? npassed.to_f/ntotal : 0; end
     end
 
     class Progress
@@ -103,19 +139,17 @@ module Ankit
         @this_round = latest_round
       end
 
-      def current_card
-        # XXX: might be better to cache
-        Card.parse(open(current_path, "r") { |f| f.read })
-      end
-
       def round_delta
         latest_round - this_round
       end
 
       def runtime; @session.runtime; end
       def last_slot; @slots[@index-1]; end
+      def last_path; last_slot.path; end
+      def last_card; card_at(last_path); end
       def current_slot; @slots[@index]; end
       def current_path; current_slot.path; end
+      def current_card; card_at(current_path); end
       def size; @slots.size; end
       def over?; @slots.size <= @index; end
       def npassed; @slots.count { |c| c.rating == :passed }; end
@@ -133,6 +167,7 @@ module Ankit
           last_slot = current_slot
           last_slot.rating = :failed
           last_slot.event = make_happen(FailCommand::EVENT_HAPPENING, to_card_name(current_path), this_round)
+          session.failed_on(last_slot.event)
         end
         
         self
@@ -143,6 +178,7 @@ module Ankit
           last_slot = current_slot
           last_slot.rating = :passed
           last_slot.event = make_happen(PassCommand::EVENT_HAPPENING, to_card_name(current_path), this_round)
+          session.passed_on(last_slot.event)
         end
 
         @index += 1
@@ -171,13 +207,14 @@ module Ankit
         end.join
       end
 
-      def update_session
-        session.npassed += npassed
-        session.nfailed += nfailed
-        session.mature_names = (session.mature_names + slots.select{ |s| 1 < s.maturity }.map(&:path)).uniq
-      end
-
       def maturities; slots.map(&:maturity);  end
+
+
+      private
+      def card_at(path)
+        # XXX: might be better to cache
+        Card.parse(open(path, "r") { |f| f.read })
+      end
     end
 
     class State
@@ -199,30 +236,21 @@ module Ankit
         runtime.stdout.print("\033[1A")
       end
 
-      def clear_screen
-        runtime.stdout.print("\033[2J")
-        h = HighLine::SystemExtensions.terminal_size[0]
-        runtime.stdout.print("\033[#{h}A")
-      end
-
       def say(msg, type=:progress)
         line.say(message_for(msg, type))
       end
 
-      def show_summary_status
-        line.say("Round #{progress.this_round}: #{progress.styled_indicator}")
+      def show_summary_header
+        status  = ["P:#{self.session.limit_reach}/#{self.session.limit}",
+                   "H:#{self.session.hitrate}",
+                   "M:" + self.session.maturity_triple.map(&:to_s).join(","),
+                   "R:#{self.progress.this_round.to_s}"
+                   ]
+        line.say(status.join(" "))
       end
 
       def show_breaking_status
-        show_summary_status
-        line.say("Maturity: #{progress.maturities.map(&:to_s).join(',')}")
-        line.say("Session: #{progress.session.summary_text}")
-        line.say("next round will be +#{progress.round_delta}")
-      end
-
-      def show_header
-        show_summary_status
-        line.say("\n")
+        show_summary_header
       end
 
       def show_and_ask_enter(msg, type)
@@ -273,116 +301,149 @@ module Ankit
       end
     end
 
-    module CommandRecognizing 
-      def may_pump_command(answered)
-        /^\/(\w+)/.match(answered) ? pump_command($1) : nil
+    module SlashRecognizing
+      def pump_slash_or(answered, &block)
+        if /^\/(\w+)/.match(answered)
+          pump_slash($1) 
+        else
+          block.call()
+        end
       end
 
-      def pump_command(command)
+      def pump_slash(command)
         case command
         when "e", "edit"
           EditState.new(progress)
         when "z", "zero"
           QuestionState.new(progress)
         else
-          raise
+          MessageState.new(progress, "Unknown command: #{command} (Available: /edit, /zero)")
+        end
+      end
+    end
+
+    class MessageState < State
+      include SlashRecognizing
+      
+      def initialize(progress, message)
+        super(progress)
+        @message = message
+      end
+
+      def pump
+        say(@message, :fail) # XXX: should :error
+        answered = ask().strip
+        pump_slash_or(answered) do
+          pump_slash(answered)
         end
       end
     end
 
     class QuestionState < State
-      include CommandRecognizing
+      include SlashRecognizing
+      attr_reader :flash
 
       def pump
         progress.attack
-        clear_screen
+        runtime.clear_screen
         show_header
         card = progress.current_card
         say("#{card.translation}")
         say("#{card.hidden_original}", :cont)
         answered = ask().strip
-        c = may_pump_command(answered)
-        return c if c
-        case card.match?(answered.strip)
-        when :match
-          PassedState.new(progress, answered)
-        when :wrong
-          FailedState.new(progress, answered)
-        when :typo
-          TypoState.new(progress, answered)
+        pump_slash_or(answered) do 
+          case card.match?(answered.strip)
+          when :match
+            PassedState.new(progress, answered)
+          when :wrong
+            FailedState.new(progress, answered)
+          when :typo
+            TypoState.new(progress, answered)
+          else
+            raise
+          end
+        end
+      end
+
+      def put_flash(flash)
+        @flash = flash
+        self
+      end
+
+      private
+
+      def show_header
+        show_summary_header
+        if flash
+          line.say(flash)
         else
-          raise
+          line.say("\n")
         end
+        line.say("\n")
       end
     end
 
-    class FailedStateBase < State
-      include CommandRecognizing
+    class FailedState < State
+      include SlashRecognizing
 
       def pump
         original = progress.current_card.corrected_original_over(last_answer)
         typed = progress.current_card.hilight_against_original(last_answer)
+        typed = "\n" if typed.empty?
         erase_last
         say("#{typed}", :ask)
-        say("#{original}", decoration_type)
+        say("#{original}", :fail)
         answered = ask("", :hit_return)
-        c = may_pump_command(answered)
-        return c if c
-        mark_progress
-        QuestionState.new(progress)
+        pump_slash_or(answered) do
+          progress.fail
+          QuestionState.new(progress)
+        end
       end
-
     end
 
-    class FailedState < FailedStateBase
-      def mark_progress
-        progress.fail
-      end
+    class PassedStateBase < State
+      include SlashRecognizing
 
-      def decoration_type
-        :fail
+      def pump
+        progress.pass
+        last_maturity = progress.last_slot.event.maturity
+        progress.over? ? RefillState.new(progress) : QuestionState.new(progress).put_flash(flash)
       end
     end
 
-    class TypoState < FailedStateBase
-      def mark_progress
-        
-      end
-
-      def decoration_type
-        :typo
+    class TypoState < PassedStateBase
+      def flash
+        hilited = progress.last_card.mixed_hilight_for_flash(last_answer)
+        StylableText.styled_text("last: ", :fyi) + hilited
       end
     end
 
-    class PassedState < State
-      include CommandRecognizing
-
-      def pump
-        progress.pass
-        last_maturity = progress.last_slot.event.maturity
-        progress.over? ? BreakingState.new(progress) : QuestionState.new(progress)
+    class PassedState < PassedStateBase
+      def flash
+        StylableText.styled_text("last: #{last_answer}", :fyi)
       end
     end
 
-    class BreakingState < State
+    class RefillState < State
       def pump
-        progress.update_session
-        clear_screen
-        show_breaking_status
+        return initial_state unless session.reached_limit?
 
-        case ask_more
+        runtime.clear_screen
+        show_breaking_status
+        case ask_over
         when :yes
-          initial_state
-        when :no
+          runtime.clear_screen
           OverState.new(progress)
+        when :no
+          initial_state
         else
           # TODO: handle help
           self
         end
       end
 
-      def ask_more
-        case line.ask("More(y/n/?) ").strip
+      def ask_over
+        case line.ask("Over(Y/n/?) ").strip
         when /^y/, ""
           :yes
         when /^n/
@@ -391,10 +452,6 @@ module Ankit
           :help
         end  
       end
-
-      def coming_limit
-        progress.size
-      end
     end
 
     class OverState < State
@@ -403,11 +460,13 @@ module Ankit
 
     module Approaching
       def initial_state
-        slots = Coming.coming_paths(self.runtime).take(self.coming_limit).map { |path| Slot.new(path, nil) }
+        # XXX: Care the case where |card| < limit
+        limit = [self.session.limit, Slot::BATCH_SIZE].min
+        slots = Coming.coming_paths(self.runtime).take(limit).map { |path| Slot.new(path, nil) }
         QuestionState.new(Progress.new(self.session, slots))
       end
     end
 
-    class BreakingState; include Approaching; end
+    class RefillState; include Approaching; end
   end
 end

data/lib/ankit/challenge_command.rb

@@ -13,12 +13,13 @@ module Ankit
       spec.on("-l", "--limit N") { |n| options[:limit] = n.to_i }
     end
 
-    DEFAULT_COUNT = 5
+    DEFAULT_COUNT = 50
 
-    def session; @session ||= Challenge::Session.make(runtime); end
+    def session; @session ||= Challenge::Session.make(runtime, coming_limit); end
 
     def execute()
       Signal.trap("INT") do
+        runtime.clear_screen
         STDERR.print("Quit.\n")
         exit(0)
       end
@@ -27,6 +28,8 @@ module Ankit
       Signal.trap("INT", "DEFAULT")
     end
 
+    private
+
     def coming_limit
       options[:limit] or DEFAULT_COUNT
     end

data/lib/ankit/event.rb

@@ -24,6 +24,7 @@ module Ankit
     def name() @values["name"]; end
     def type() @values["type"]; end
     def maturity() @values["maturity"] || 0; end
+    def best() @values["best"] || maturity; end
     def card?() type == "card"; end
     def round() @envelope.round or 0; end
     def next_round() round + 2**maturity; end
@@ -39,11 +40,11 @@ module Ankit
     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 }))
+      Event.new(env, Event.sweep(@values.merge({ "verb" => "passed", "maturity" => next_maturity })))
     end
 
     def to_failed(env)
-      Event.new(env, @values.merge({ "verb" => "failed", "maturity" => 0 }))
+      Event.new(env, @values.merge({ "verb" => "failed", "maturity" => 0, "best" => best }))
     end
 
     def self.for_card(name, verb, env)
@@ -52,6 +53,17 @@ module Ankit
 
     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
+
+    def self.sweep(values)
+      values.delete("best") if values.include?("best") and values["best"] <= values["maturity"]
+      values
+    end
+
+    private
+
+    def next_maturity
+      maturity + [(best - maturity)/2, 1].max
+    end
   end
 
   module EventFormatting

data/lib/ankit/runtime.rb

@@ -135,6 +135,14 @@ module Ankit
       saved
     end
 
+    def clear_screen
+      w = HighLine::SystemExtensions.terminal_size[1]
+      stdout.print("\033[#{w}D")
+      stdout.print("\033[2J")
+      h = HighLine::SystemExtensions.terminal_size[0]
+      stdout.print("\033[#{h}A")
+    end
+
     def unsupress_io(saved)
       @stdin, @stdout, @stderr =  saved
     end

data/test/command_test.rb

@@ -149,7 +149,7 @@ class AddTest < Test::Unit::TestCase
     end
   end
 
-  def test_hello_two_file
+  def test_hello_two_files
     with_runtime_on_temp_repo do |target|
       dst_dir = target.config.card_search_paths[1]
       assert_written(target.dispatch_then(["add", test_data_at("hope.card"), test_data_at("luck.card")]),
@@ -157,6 +157,15 @@ class AddTest < Test::Unit::TestCase
                       File.join(target.config.card_paths[0], "luck-is-not-chance.card")])
     end
   end
+
+  def test_hello_two_chunks
+    with_runtime_on_temp_repo do |target|
+      dst_dir = target.config.card_search_paths[1]
+      assert_written(target.dispatch_then(["add", test_data_at("hope-and-luck.txt")]),
+                     [File.join(target.config.card_paths[0], "hope-is-the-thing-with-feathers.card"),
+                      File.join(target.config.card_paths[0], "luck-is-not-chance.card")])
+    end
+  end
 end
 
 class ComingTest < Test::Unit::TestCase
@@ -264,8 +273,9 @@ class ChallengeTest < Test::Unit::TestCase
 
   def test_initial_state_limit_default
     runtime = make_runtime(NUMBER_REPO)
-    actual = runtime.make_command(["challenge"]).initial_state
-    assert_equal(actual.progress.size, ChallengeCommand::DEFAULT_COUNT)
+    limit = 5
+    actual = runtime.make_command(["challenge", "--limit", limit.to_s]).initial_state
+    assert_equal(actual.progress.size, limit)
   end
 
   def test_initial_state_limit_args
@@ -300,6 +310,13 @@ class ChallengeTest < Test::Unit::TestCase
     state.pump
   end
 
+  def agree_pump(state, that)
+    state.progress.runtime.line = HighLine.new
+    state.progress.runtime.line.stubs(:say).at_least(0)
+    state.progress.runtime.line.stubs(:ask).once().returns(that)
+    state.pump
+  end
+
   def test_question_to_fail
     with_runtime_on_temp_repo do |runtime|
       actual = ChallengeCommand.new(runtime).initial_state
@@ -312,6 +329,17 @@ class ChallengeTest < Test::Unit::TestCase
     end
   end
 
+  def test_question_to_unknown_command
+    with_runtime_on_temp_repo do |runtime|
+      actual = ChallengeCommand.new(runtime).initial_state
+      assert_instance_of(Challenge::QuestionState, actual)
+      actual = enter_text_pump(actual, "/unknown")
+      assert_instance_of(Challenge::MessageState, actual)
+      actual = enter_text_pump(actual, "/zero")
+      assert_instance_of(Challenge::QuestionState, actual)
+    end
+  end
+
   def test_question_to_fail_but_zero_it
     with_runtime_on_temp_repo do |runtime|
       actual = ChallengeCommand.new(runtime).initial_state
@@ -329,13 +357,8 @@ class ChallengeTest < Test::Unit::TestCase
       actual = ChallengeCommand.new(runtime).initial_state
       actual_next = enter_text_pump(actual, FIRST_TYPO_ANSWER)
       assert_instance_of(Challenge::TypoState, actual_next)
-      actual_next = hit_return_pump(actual_next)
+      actual_next = actual_next.pump
       assert_instance_of(Challenge::QuestionState, actual_next)
-      assert_equal(actual_next.progress.npassed, 0)
-      assert_equal(actual_next.progress.nfailed, 0)
-      actual_next = enter_text_pump(actual_next, FIRST_CORRECT_ANSWER)
-      assert_instance_of(Challenge::PassedState, actual_next)
-      actual_next.pump
       assert_equal(actual_next.progress.npassed, 1)
       assert_equal(actual_next.progress.nfailed, 0)
     end
@@ -365,38 +388,39 @@ class ChallengeTest < Test::Unit::TestCase
     state
   end
 
-  def test_to_breaking
+  def test_to_refill
     with_runtime_on_temp_repo do |runtime|
       actual = ChallengeCommand.new(runtime).initial_state
       actual_next = pass_two(actual)
-      assert_instance_of(Challenge::BreakingState, actual_next)
+      assert_instance_of(Challenge::RefillState, actual_next)
     end
   end
 
-  def test_to_breaking_to_over
+  def test_to_refill_to_over
     with_runtime_on_temp_repo do |runtime|
-      actual = ChallengeCommand.new(runtime).initial_state
+      actual = ChallengeCommand.new(runtime, ["--limit", "2"]).initial_state
       actual = pass_two(actual)
-      actual = agree_pump(actual, "n")
+      actual = agree_pump(actual, "y")
       assert_instance_of(Challenge::OverState, actual)
     end
   end
 
-  def test_to_breaking_to_more
+  def test_to_refill_to_more
     with_runtime_on_temp_repo do |runtime|
-      actual = ChallengeCommand.new(runtime).initial_state
+      actual = ChallengeCommand.new(runtime, ["--limit", "2"]).initial_state
       actual = pass_two(actual)
-      actual = agree_pump(actual, "y")
+      p actual.class
+      actual = agree_pump(actual, "n")
       assert_instance_of(Challenge::QuestionState, actual)
     end
   end
 
-  def test_to_breaking_to_more
+  def test_to_refill_to_more
     with_runtime_on_temp_repo do |runtime|
-      actual = ChallengeCommand.new(runtime).initial_state
+      actual = ChallengeCommand.new(runtime, ["--limit", "2"]).initial_state
       actual = pass_two(actual)
       actual = agree_pump(actual, "?")
-      assert_instance_of(Challenge::BreakingState, actual)
+      assert_instance_of(Challenge::RefillState, actual)
     end
   end
 end

data/test/data/hope-and-luck.txt

@@ -0,0 +1,4 @@
+O: Hope is the thing with feathers
+
+
+O: Luck is not chance

data/test/event_test.rb

@@ -9,6 +9,7 @@ class EventTest < Test::Unit::TestCase
     @target = Event.parse('{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":1},' +
                           '"values":{"type":"card","verb":"add","name":"hello","maturity":1}}')
     @next_envelope = Envelope.parse('{"at":"2002-03-04T05:06:07+00:00","round":2}')
+    @another_next_envelope = Envelope.parse('{"at":"2002-03-04T05:06:08+00:00","round":3}')
   end
 
   def test_to_passed
@@ -17,10 +18,30 @@ class EventTest < Test::Unit::TestCase
     assert_equal(actual, expected)
   end
 
+  def test_to_passed_recovering
+    recovering_target = Event.parse('{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":1},' +
+                                    '"values":{"type":"card","verb":"add","name":"hello","maturity":1,"best":6}}')
+    expected = Event.new(@next_envelope, JSON.parse('{"type":"card","verb":"passed","name":"hello","maturity":3,"best":6}'))
+    actual = recovering_target.to_passed(@next_envelope)
+    assert_equal(actual, expected)
+  end
+
+  def test_to_passed_recovering_to_best
+    recovering_target = Event.parse('{"envelope":{"at":"2001-02-03T04:05:06+00:00","round":1},' +
+                                    '"values":{"type":"card","verb":"add","name":"hello","maturity":5,"best":6}}')
+    expected = Event.new(@next_envelope, JSON.parse('{"type":"card","verb":"passed","name":"hello","maturity":6}'))
+    actual = recovering_target.to_passed(@next_envelope)
+    assert_equal(actual, expected)
+  end
+
   def test_to_failed
-    expected = Event.new(@next_envelope, JSON.parse('{"type":"card","verb":"failed","name":"hello","maturity":0}'))
+    json = JSON.parse('{"type":"card","verb":"failed","name":"hello","maturity":0,"best":1}')
+    expected = Event.new(@next_envelope, json)
     actual = @target.to_failed(@next_envelope)
     assert_equal(actual, expected)
+    another_expected = Event.new(@another_next_envelope, json)
+    actual = @target.to_failed(@another_next_envelope)
+    assert_equal(actual, another_expected)
   end
 
   def test_next_round

data/test/progress_test.rb

@@ -8,8 +8,8 @@ class ProgressTest < Test::Unit::TestCase
   include Ankit::CardNaming
   include Challenge
 
-  def make_target(runtime)
-    Progress.new(Session.new(runtime), [Slot.new("path1"), Slot.new("path2"), Slot.new("path3")])
+  def make_target(runtime, sess=nil)
+    Progress.new(sess || Session.make(runtime, 5), [Slot.new("path1"), Slot.new("path2"), Slot.new("path3")])
   end
 
   def first_slot_event_of(progress)
@@ -47,6 +47,32 @@ class ProgressTest < Test::Unit::TestCase
     end
   end
 
+  def test_passed_size
+    with_runtime_on_temp_repo do |runtime|
+      target1 = make_target(runtime)
+      session = target1.session
+
+      target1.pass
+      assert_equal(session.limit_reach, 1)
+      target1.pass
+      assert_equal(session.limit_reach, 2)
+      target1.fail
+      assert_equal(session.limit_reach, 2)
+      target1.pass
+      assert_equal(session.limit_reach, 2)
+      
+      target2 = make_target(runtime, session)
+      target2.fail
+      assert_equal(session.limit_reach, 2)
+      target2.pass
+      assert_equal(session.limit_reach, 2)
+      target2.pass
+      assert_equal(session.limit_reach, 2)
+      target2.pass
+      assert_equal(session.limit_reach, 3)
+    end
+  end
+
   def test_fail_then_pass
     with_runtime_on_temp_repo do |runtime|
       target = make_target(runtime)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ankit
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-10 00:00:00.000000000 Z
+date: 2012-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
-  requirement: &20716680 !ruby/object:Gem::Requirement
+  requirement: &7184500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.6.11
   type: :runtime
   prerelease: false
-  version_requirements: *20716680
+  version_requirements: *7184500
 - !ruby/object:Gem::Dependency
   name: diff-lcs
-  requirement: &20716160 !ruby/object:Gem::Requirement
+  requirement: &7183860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 1.1.3
   type: :runtime
   prerelease: false
-  version_requirements: *20716160
+  version_requirements: *7183860
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &20715660 !ruby/object:Gem::Requirement
+  requirement: &7183300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: 1.6.5
   type: :runtime
   prerelease: false
-  version_requirements: *20715660
+  version_requirements: *7183300
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &20715080 !ruby/object:Gem::Requirement
+  requirement: &7182720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: 0.10.4
   type: :development
   prerelease: false
-  version_requirements: *20715080
+  version_requirements: *7182720
 description: ! 'Ankit is a CLI and terminal based flashcard program to learn your
   new language.
 
@@ -87,6 +87,7 @@ files:
 - lib/ankit/list_command.rb
 - lib/ankit.rb
 - test/data/vanilla_repo/anemone.journal
+- test/data/hope-and-luck.txt
 - test/data/hello_card.card
 - test/data/hello_repo/cards/foo/this_is_not_a_card.txt
 - test/data/hello_repo/cards/foo/vanilla-please.card