cliptic 0.1.0

data/lib/cliptic/database.rb

@@ -0,0 +1,247 @@
+module Cliptic
+  module Database
+    Dir_Path  = "#{Dir.home}/.config/cliptic/db"
+    File_Path = "#{Dir_Path}/cliptic.db"
+    class SQL
+      attr_reader :db, :table
+      def initialize(table:)
+        make_db_dir
+        @table = table
+        @db    = SQLite3::Database.open(File_Path)
+        db.results_as_hash = true
+        self
+      end
+      def make_table
+        db.execute(sql_make)
+      end
+      def select(cols:"*", where:nil, order:false, limit:false)
+        db.execute(
+          sql_select(cols:cols, where:where, 
+                     order:order, limit:limit),
+          where&.values&.map(&:to_s)
+        )
+      end
+      def insert(values:)
+        db.execute(sql_insert(values:values), 
+                   values.values)
+      end
+      def update(values:, where:)
+        db.execute(sql_update(values:values, where:where), [values.values], [where.values])
+      end
+      def delete(where:nil)
+        db.execute(sql_delete(where:where), where&.values)
+      end
+      def drop
+        db.execute("DROP TABLE #{table}")
+      end
+      private
+      def make_db_dir
+        FileUtils.mkdir_p(Dir_Path) unless Dir.exist?(Dir_Path)
+      end
+      def sql_make
+        "CREATE TABLE IF NOT EXISTS #{table}(#{
+          cols.map{|col,type|"#{col} #{type}"}.join(", ")
+        })"
+      end
+      def sql_select(cols:, where:, order:, limit:)
+        "SELECT #{cols} FROM #{table}" +
+          (where ? where_str(where)  : "") +
+          (order ? order_str(order)  : "") +
+          (limit ? " LIMIT #{limit}" : "")
+      end
+      def sql_insert(values:)
+        <<~sql
+        INSERT INTO #{table}(#{values.keys.join(", ")})
+        VALUES (#{Array.new(values.length, "?").join(", ")})
+        sql
+      end
+      def sql_update(values:, where:)
+        <<~sql
+        UPDATE #{table}
+        SET #{placeholder(values.keys, ", ")}
+        WHERE #{placeholder(where.keys)}
+        sql
+      end
+      def sql_delete(where:)
+        <<~sql
+        DELETE FROM #{table} #{where ? where_str(where) : ""}
+        sql
+      end
+      def where_str(where)
+        " WHERE #{placeholder(where.keys)}"
+      end
+      def order_str(order)
+        " ORDER BY #{order.keys
+          .map{|k| "#{k} #{order[k]}"}
+          .join(", ")}" 
+      end
+      def placeholder(keys, glue=" AND ")
+        keys.map{|k| "#{k} = ?"}.join(glue)
+      end
+    end
+    class Delete
+      def self.table(table)
+        SQL.new(table:table).drop
+      end
+      def self.all
+        File.delete(File_Path)
+      end
+    end
+    class State < SQL
+      include Chars
+      attr_reader :date, :time, :chars, :n_done, :n_tot,
+        :reveals, :done
+      attr_accessor :reveals
+      def initialize(date:Date.today)
+        super(table:"states").make_table
+        @date = date
+        set
+      end
+      def cols
+        {
+          date: :DATE, time: :INT, chars: :TEXT, 
+          n_done: :INT, n_tot: :INT, reveals: :INT, 
+          done: :INT
+        }
+      end
+      def exists?
+        @exists || query.count > 0
+      end
+      def save(game:)
+        exists? ? save_existing(game) : save_new(game)
+      end
+      def delete
+        super(where:{date:date.to_s})
+        @exists = false
+        set
+      end
+      private
+      def set
+        @time,@chars,@n_done,@n_tot,@reveals,@done =
+          exists? ? instantiate : blank
+      end
+      def instantiate
+        [
+          query[0]["time"].to_i,
+          parse_chars(query[0]["chars"]),
+          query[0]["n_done"].to_i,
+          query[0]["n_tot"].to_i,
+          query[0]["reveals"].to_i,
+          query[0]["done"].to_i == 1
+        ]
+      end
+      def blank
+        [ 0, false, nil, nil, 0, false ]
+      end
+      def query
+        @query || select(where:{date:date})
+      end
+      def parse_chars(str)
+        JSON.parse(str, symbolize_names:true)
+      end
+      def build(game:)
+        {
+          date:    date.to_s,
+          time:    game.timer.time.to_i,
+          chars:   gen_chars(game),
+          n_done:  game.board.puzzle.n_clues_done,
+          n_tot:   game.board.puzzle.n_clues,
+          reveals: reveals,
+          done:    game.board.puzzle.complete? ? 1 : 0
+        }
+      end
+      def gen_chars(game)
+        JSON.generate(game.board.save_state)
+      end
+      def save_existing(game)
+        update(where:{date:date.to_s}, values:build(game:game))
+      end
+      def save_new(game)
+        insert(values:build(game:game))
+        @exists = true
+      end
+    end
+    class Stats < State
+      def initialize(date:Date.today)
+        super(date:date)
+      end
+      def stats_str
+        (exists? ? exist_str : new_str).split("\n")
+      end
+      def exist_str
+        <<~stats
+          Time  #{VL} #{Time.abs(time).to_s}
+          Clues #{VL} #{n_done}/#{n_tot}
+          Done  #{VL} [#{done ? Tick : " "}]
+        stats
+      end
+      def new_str
+        "\n  Not attempted\n"
+      end
+    end
+    class Recents < SQL
+      attr_reader :date
+      def initialize
+        super(table:"recents").make_table
+      end
+      def cols
+        {
+          date: :DATE,
+          play_date: :DATE,
+          play_time: :TIME
+        }
+      end
+      def select_list
+        select(cols:"*", order:{play_date:"DESC", play_time:"DESC"}, limit:10)
+      end
+      def add(date:)
+        @date = date
+        exists? ? add_existing : add_new
+      end
+      def exists?
+        select(where:{date:date.to_s}).count > 0
+      end
+      def add_new
+        insert(values:build)
+      end
+      def add_existing
+        update(values:build, where:{date:date.to_s})
+      end
+      def build
+        {
+          date:      date.to_s,
+          play_date: Date.today.to_s,
+          play_time: Time.now.strftime("%T")
+        }
+      end
+    end
+    class Scores < SQL
+      def initialize
+        super(table:"scores").make_table
+      end
+      def cols
+        {
+          date: :DATE,
+          date_done: :DATE,
+          time: :TEXT,
+          reveals: :INT
+        }
+      end
+      def add(game:)
+        insert(values:build(game:game))
+      end
+      def select_list
+        select(cols:"*", where:{reveals:0}, 
+               order:{time:"ASC"}, limit:10)
+      end
+      def build(game:)
+        {
+          date:game.date.to_s,
+          date_done:Date.today.to_s,
+          time:game.timer.time.strftime("%T"),
+          reveals:game.state.reveals
+        }
+      end
+    end
+  end
+end

data/lib/cliptic/interface.rb

@@ -0,0 +1,270 @@
+module Cliptic
+  module Interface
+    class Top_Bar < Windows::Bar
+      attr_reader :date
+      def initialize(date:Date.today)
+        super(line:0)
+        @date = date
+      end
+      def draw
+        super
+        add_str(x:1, str:title, bold:true)
+        add_str(x:title.length+2, str:date.to_long)
+      end
+      def title
+        "cliptic:"
+      end
+      def reset_pos
+        move(line:0, col:0)
+      end
+    end
+    class Bottom_Bar < Windows::Bar
+      def initialize
+        super(line:Curses.lines-1)
+      end
+      def draw
+        super
+        noutrefresh
+      end
+      def reset_pos
+        move(line:Curses.lines-1, col:0)
+      end
+    end
+    class Logo < Windows::Grid
+      attr_reader :text
+      def initialize(line:, text:"CLIptic")
+        super(y:1, x:text.length, line:line)
+        @text = text
+      end
+      def draw(cp_grid:$colors[:logo_grid], 
+               cp_text:$colors[:logo_text], bold:true)
+        super(cp:cp_grid)
+        bold(bold).color(cp_text)
+        add_str(str:text)
+        reset_attrs
+        refresh
+      end
+    end
+    class Menu_Box < Windows::Window
+      include Interface
+      attr_reader :logo, :title, :top_b, :bot_b, :draw_bars
+      def initialize(y:, title:false)
+        @logo = Logo.new(line:line+1)
+        @title = title
+        super(y:y, x:logo.x+4, line:line, col:nil)
+        @top_b = Top_Bar.new
+        @bot_b = Bottom_Bar.new
+        @draw_bars = true
+      end
+      def draw
+        super
+        [top_b, bot_b].each(&:draw) if draw_bars
+        logo.draw
+        add_title if title
+        self
+      end
+      def line
+        (Curses.lines-15)/2
+      end
+      def add_title(y:4, str:title, cp:$colors[:title], bold:true)
+        add_str(y:y, str:str, cp:cp, bold:bold)
+      end
+      def reset_pos
+        move(line:line)
+        logo.move(line:line+1)
+        [top_b, bot_b].each(&:reset_pos)
+      end
+    end
+    class Resizer < Menu_Box
+      def initialize
+        super(y:8, title:title)
+      end
+      def title
+        "Screen too small"
+      end
+      def draw
+        Screen.clear
+        reset_pos
+        super
+        wrap_str(str:prompt, line:5)
+        refresh
+      end
+      def show
+        while Screen.too_small?
+          draw; getch
+        end
+      end
+      def prompt
+        "Screen too small. Increase screen size to run cliptic."
+      end
+    end
+    class Selector < Windows::Window
+      attr_reader :opts, :ctrls, :run, :tick
+      attr_accessor :cursor
+      def initialize(opts:, ctrls:, x:, line:,
+                     tick:nil, y:opts.length, col:nil)
+        super(y:y, x:x, line:line, col:col)
+        @opts, @ctrls, @tick = opts, ctrls, tick
+        @cursor, @run = 0, true
+      end
+      def select
+        while @run
+          draw
+          ctrls[getch]&.call
+        end
+      end
+      def stop
+        @run = false
+      end
+      def cursor=(n)
+        @cursor = Pos.wrap(val:n,min:0,max:opts.length-1)
+      end
+      private
+      def draw
+        Curses.curs_set(0)
+        setpos
+        opts.each_with_index do |opt, i|
+          standout if cursor == i
+          self << format_opt(opt)
+          standend
+        end
+        tick.call if tick
+        refresh
+      end
+      def format_opt(opt)
+        opt.to_s.center(x)
+      end
+    end
+    class Date_Selector < Selector
+      def initialize(opts:, ctrls:, line:, x:18, tick:)
+        super(y:1, x:18, opts:opts, 
+              ctrls:ctrls, line:line, tick:tick)
+      end
+      def format_opt(opt)
+        opt.to_s.rjust(2, "0").center(6)
+      end
+    end
+    class Stat_Window < Windows::Window
+      def initialize(y:5, x:33, line:)
+        super(y:y, x:x, line:line)
+      end
+      def show(date:, cp:$colors[:stats])
+        draw(clr:true).color(cp)
+        get_stats(date:date).each_with_index do |line, i|
+          setpos(i+1, 8)
+          self << line
+        end
+        color.noutrefresh
+      end
+      def get_stats(date:)
+        Database::Stats.new(date:date).stats_str
+      end
+    end
+    class Menu < Menu_Box
+      attr_reader :selector, :height
+      def initialize(height:opts.length+6,
+                     sel:Selector, sel_opts:opts.keys,
+                     tick:nil, **)
+        super(y:height, title:title)
+        @height = height
+        @selector = sel.new(opts:sel_opts, ctrls:ctrls, line:line+5, x:logo.x, tick:tick)
+      end
+      def choose_opt
+        show
+        selector.select
+      end
+      def enter(pre_proc:->{hide}, post_proc:->{show})
+        pre_proc.call if pre_proc
+        opts.values[selector.cursor]&.call
+        post_proc.call if post_proc
+      end
+      def back(post_proc:->{hide})
+        selector.stop
+        post_proc.call if post_proc
+      end
+      def show
+        draw
+      end
+      def hide
+        clear
+      end
+      def ctrls
+        {
+          ?j  => ->{selector.cursor += 1},
+          ?k  => ->{selector.cursor -= 1},
+          258 => ->{selector.cursor += 1},
+          259 => ->{selector.cursor -= 1},
+          10  => ->{enter},
+          ?q  => ->{back},
+          3   => ->{back},
+          Curses::KEY_RESIZE => 
+            ->{Screen.redraw(cb:->{redraw})}
+        }
+      end
+      def reset_pos
+        super
+        selector.move(line:line+5)
+      end
+      def redraw
+        reset_pos
+        draw
+      end
+    end
+    class Menu_With_Stats < Menu
+      attr_reader :stat_win
+      def initialize(height:opts.length+6, sel:Selector, **)
+        super(height:height, sel:sel, sel_opts:opts, 
+              tick:->{update_stats})
+        @stat_win = Stat_Window.new(line:line+height)
+      end
+      def update_stats
+        stat_win.show(date:stat_date)
+      end
+      def hide
+        super
+        stat_win.clear
+      end
+      def enter
+        hide
+        Main::Player::Game.new(date:stat_date).play
+        show
+      end
+      def reset_pos
+        super
+        stat_win.move(line:line+height)
+      end
+    end
+    class SQL_Menu_With_Stats < Menu_With_Stats
+      include Database
+      attr_reader :dates
+      def initialize(table:)
+        @dates = table.new
+          .select_list.map{|d| Date.parse(d[0])}
+        super
+      end
+      def opts
+        dates.map{|d| d.to_long} || [nil]
+      end
+      def stat_date
+        dates[selector.cursor]
+      end
+    end
+    class Yes_No_Menu < Menu
+      attr_reader :yes, :no, :post_proc
+      def initialize(yes:, no:->{back}, post_proc:nil, title:nil)
+        super
+        @title = title
+        @yes, @no, @post_proc = yes, no, post_proc
+      end
+      def opts
+        {
+          "Yes" => ->{yes.call; back; post},
+          "No"  => ->{no.call; post}
+        }
+      end
+      def post
+        post_proc.call if post_proc
+      end
+    end
+  end
+end