engine 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 668d7179c24a01408a2a5a9662ef97e34f541438
+  data.tar.gz: af96c0c16a180cfc759f17659486a4272df85bc9
+SHA512:
+  metadata.gz: 8a05758d9e2d029ed925ab197b4f8c30ed29d2b0a42348ef58e2c7b84f79bcf3ad5f770e7c7102924fb7756f658eb69efd25dda8b474d7bc2d339c66a4bd178a
+  data.tar.gz: a83d69cef23e40c28762d4633083082b7116968759923bf508ba00aee8c532b2d694902f385cedfc41c4e818e8d16d71cef571a25c2b7c9a172a8858f083c1fb

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/README.md

@@ -0,0 +1 @@
+Flashcard Engine with Spaced Repetition

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems/package_task'
+
+spec = Gem::Specification.load(File.expand_path('../engine.gemspec', __FILE__))
+gem = Gem::PackageTask.new(spec)
+gem.define
+
+desc "Push gem to rubygems.org"
+task :push => :gem do
+  #sh "git tag v#{Engine::VERSION}"
+  sh "git push --tags"
+  sh "gem push pkg/engine-#{Engine::VERSION}.gem"
+end

data/engine.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/engine/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'engine'
+  gem.version     = Engine::VERSION
+  gem.authors     = [ 'Arne Brasseur' ]
+  gem.email       = [ 'arne@arnebrasseur.net' ]
+  gem.description = 'Flashcard Engine with Spaced Repetition.'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/plexus/engine'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec`.split($/)
+  gem.extra_rdoc_files = %w[README.md]
+
+  gem.add_runtime_dependency 'hexp', '~> 0.2.0'
+
+  gem.add_development_dependency 'rake', '~> 10.1'
+  gem.add_development_dependency 'rspec', '~> 2.14'
+end

data/lib/engine/card.rb

@@ -0,0 +1,23 @@
+module XFlash
+  class Card < Struct.new(:data, :card_state)
+    extend Forwardable
+    def_delegators :card_state, :factor, :iteration, :streak, :interval, :expired?, :expired_for_seconds, :last_shown
+
+    def new?
+      card_state.empty?
+    end
+
+    def rate(rating)
+      next_card_state = card_state << Rating.new(Time.now, rating)
+      self.class.new(data, next_card_state)
+    end
+
+    def lapsed?
+      streak == 0
+    end
+
+    def inspect
+      "<Card #{data.inspect} #{card_state.inspect}>"
+    end
+  end
+end

data/lib/engine/card_state.rb

@@ -0,0 +1,58 @@
+module XFlash
+
+  # CardStates form a linked list, each pointing to the previous state plus
+  # the new data point. The actual factor/interval, streak are calculated
+  # recursively based on the previous value, and the new data point.
+  class CardState < Struct.new(:parent, :data_point)
+    STRATEGY = AnkiStrategy
+    EMPTY = CardState.new
+
+    START = {
+      iteration: 0,
+      streak: 0,
+      factor: 2.5,
+      interval: 1
+    }
+
+    def << data_point
+      self.class.new(self, data_point)
+    end
+
+    def strategy
+      STRATEGY.new(parent, data_point)
+    end
+
+    def empty?
+      parent.nil?
+    end
+
+    def data_points(&blk)
+      return to_enum(__method__) unless block_given?
+      unless empty?
+        parent.data_points(&blk)
+        yield data_point
+      end
+    end
+
+    def last_shown
+      data_points.to_a.last.timestamp
+    end
+
+    def expired?(time)
+      (!empty? && data_point.fail?) || expired_for_seconds(time) > 0
+    end
+
+    def expired_for_seconds(time)
+      empty? ? 0 : [time - last_shown - interval * 60, 0].max
+    end
+
+    def iteration ; empty? ? START[:iteration] : parent.iteration + 1   end
+    def streak    ; empty? ? START[:streak]    : strategy.next_streak   end
+    def factor    ; empty? ? START[:factor]    : strategy.next_factor   end
+    def interval  ; empty? ? START[:interval]  : strategy.next_interval end
+
+    def inspect
+      "<#{self.class} iteration: %d, streak: %d, factor: %.2f, interval: %.2f>" % [iteration, streak, factor, interval]
+    end
+  end
+end

data/lib/engine/cli.rb

@@ -0,0 +1,36 @@
+module XFlash
+  class CLI
+    attr_reader :card, :cards
+    def initialize(cards)
+      @cards = Deck.new(cards)
+    end
+
+    def next_card
+      @card = cards.sample
+    end
+
+    def rate_card(score)
+      puts "Before : " + card.inspect
+      card.rate(score).tap do |new_card|
+        @cards = @cards.update_card(card, new_card)
+        @card  = new_card
+      end
+      puts "After  : " + card.inspect
+    end
+
+    def readline_loop
+      next_card
+      loop do
+        input = Readline.readline("#{card.data.first} > ", true)
+        exit unless input
+        case input
+        when /s/, ""
+          puts card.data.last
+        when /[0-5]/
+          rate_card(input.to_i)
+          next_card
+        end
+      end
+    end
+  end
+end

data/lib/engine/deck.rb

@@ -0,0 +1,23 @@
+module XFlash
+  class Deck < DelegateClass(Array)
+    %w[select map reject grep reverse sort_by sort].each do |array_method|
+      define_method array_method do |*args, &blk|
+        self.class.new(super(*args, &blk))
+      end
+    end
+
+    def expired_cards(time)
+      select {|card| card.expired?(time) }.sort_by do |card|
+        [card.expired_for_seconds(time), -card.last_shown.to_i]
+      end.reverse
+    end
+
+    def new_cards
+      select(&:new?)
+    end
+
+    def update_card(old, new)
+      self.class.new(take(index(old)) + [new] + drop(index(old) + 1))
+    end
+  end
+end

data/lib/engine/fixtures.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+module XFlash
+  FIXTURES = [
+    [ '入選', "(入选) [ru4 xuan3] /to be chosen/to be elected as/" ],
+    [ '報名', "(报名) [bao4 ming2] /to sign up/to enter one's name/to apply/to register/to enroll/to enlist/" ],
+    [ '訊息', "(讯息) [xun4 xi1] /information/news/message/text message or SMS/" ],
+    [ '詢問', "(询问) [xun2 wen4] /to inquire/" ],
+    [ '導致', "(导致) [dao3 zhi4] /to lead to/to create/to cause/to bring about/" ],
+    [ '琴', "[qin2] /guqin or zither, cf 古琴[gu3 qin2]/musical instrument in general/" ],
+    [ '提供', "[ti2 gong1] /to offer/to supply/to provide/to furnish/" ],
+    [ '更新', "[geng1 xin1] /to replace the old with new/to renew/to renovate/to upgrade/to update/to regenerate/" ],
+    [ '出力', "[chu1 li4] /to exert oneself/" ],
+    [ '拌蒜', "[ban4 suan4] /to stagger (walk unsteadily)/" ],
+  ].map{|args| Card.new(args, CardState::EMPTY)}
+end

data/lib/engine/rating.rb

@@ -0,0 +1,18 @@
+module XFlash
+  class Rating < Struct.new(:timestamp, :rating)
+    MAX_RATING = 3
+    FAIL = 0
+    HARD = 1
+    GOOD = 2
+    EASY = 3
+
+    def neg_rating
+      MAX_RATING - rating
+    end
+
+    def fail? ; rating == FAIL end
+    def hard? ; rating == HARD end
+    def good? ; rating == GOOD end
+    def easy? ; rating == EASY end
+  end
+end

data/lib/engine/strategies.rb

@@ -0,0 +1,66 @@
+module XFlash
+  class BaseStrategy < Struct.new(:card_state, :data_point)
+    extend Forwardable
+    def_delegators :card_state, :data_points, :iteration, :streak, :factor, :interval
+    def_delegators :data_point, :fail?, :rating, :neg_rating
+  end
+
+  class SuperMemoStrategy < BaseStrategy
+    INITIAL_INTERVALS = [1, 6]
+
+    def next_streak
+      fail? ? 0 : streak + 1
+    end
+
+    def next_factor
+      [factor + (0.1 - neg_rating * (0.28 + neg_rating * 0.02)), 1.3].max
+    end
+
+    def next_interval
+      INITIAL_INTERVALS.fetch(next_streak) do
+        interval * next_factor
+      end
+    end
+  end
+
+  class AnkiStrategy < BaseStrategy
+    LEARNING_INTERVALS = [0, 1, 10, 25].map(&:to_f)
+    INITIAL_INTERVALS  = [1, 2].map {|min| min*60*24 }.map(&:to_f)
+    LEARNING_STEPS     = LEARNING_INTERVALS.length - 1
+
+    def learning?
+      steps_to_graduation > 0
+    end
+
+    def steps_to_graduation
+      data_points.map(&:rating).inject(LEARNING_STEPS, :-)
+    end
+
+    def next_streak
+      fail? || learning? ? 0 : streak + 1
+    end
+
+    def next_factor
+      if learning?
+        factor
+      else
+        [factor + [0.15, 0, -0.15, -0.3].fetch(neg_rating) {0}, 1.3].max
+      end
+    end
+
+    # Good enough for our purposes, and stable for a given card-state
+    def pseudo_rand
+      data_point.timestamp.to_f % 1
+    end
+
+    def next_interval
+      if learning?
+        LEARNING_INTERVALS.fetch(-steps_to_graduation)
+      else
+        INITIAL_INTERVALS.fetch(next_streak) do
+          interval * next_factor
+        end
+      end * (0.8 + pseudo_rand * 0.4) # 0.8 - 1.2
+    end
+  end
+end

data/lib/engine/version.rb

@@ -0,0 +1,3 @@
+module Engine
+  VERSION = '0.0.0'
+end

data/lib/engine.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+require 'pathname'
+require 'yaml'
+#require 'readline'
+require 'forwardable'
+require 'delegate'
+
+require_relative 'engine/rating'
+require_relative 'engine/strategies'
+require_relative 'engine/card_state'
+require_relative 'engine/card'
+require_relative 'engine/fixtures'
+require_relative 'engine/deck'
+#require_relative 'engine/cli'
+
+module Engine
+end
+
+#Engine::CLI.new(Engine::FIXTURES).readline_loop

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: engine
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Arne Brasseur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hexp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: Flashcard Engine with Spaced Repetition.
+email:
+- arne@arnebrasseur.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- ".gitignore"
+- README.md
+- Rakefile
+- engine.gemspec
+- lib/engine.rb
+- lib/engine/card.rb
+- lib/engine/card_state.rb
+- lib/engine/cli.rb
+- lib/engine/deck.rb
+- lib/engine/fixtures.rb
+- lib/engine/rating.rb
+- lib/engine/strategies.rb
+- lib/engine/version.rb
+homepage: https://github.com/plexus/engine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Flashcard Engine with Spaced Repetition.
+test_files: []