diary-ruby 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43c0fd4d3d17a68ab7a208cb55d3ba585d02a714
-  data.tar.gz: 89d2f6271d276120406f36f9383b9a527b54776e
+  metadata.gz: 2f7c7aa9aab6f4119776f1ec8e197487beddc6b0
+  data.tar.gz: d706e3f057f2ba5911e79bf8273057127b21db19
 SHA512:
-  metadata.gz: 4f74fcb7dc21a055383fdfec15e2ad122e007dd74bc2829c5d20951208065f028ce27cc1af44f902fc01c3963d39cb170c3f8e0759aebba2d0d5de7771a02119
-  data.tar.gz: 0763ab123ad356789eab5b90b1b95afac7abeb3a6e11a395feb845d60e44bda874964466335fcf86467f51d8d6a3f78ae9aac852821c02e1f95e04d69dab3039
+  metadata.gz: 1b43c04f2ae1cd94d0e2df2ea58c351a3969b65cf95778f1018bf1d90d586f337cee7cbb8b2be4dd9e39cb435956f10f8b334e79c27881dbc595c9929b9ea88d
+  data.tar.gz: 82806e6364fb1405b7c521769a1cfac4b2cab2a8da4cc495e42f0e7cc4e1f0ad10bb69d6fc7d7702cf042eb5a29aa4881dd4d5620c89817b3d745117560785aa

data/.gitignore

@@ -7,5 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+/*.db
 /*.store
 /.diaryrb/
+/.*~

data/.travis.yml

@@ -2,3 +2,5 @@ language: ruby
 rvm:
   - 2.2.1
 before_install: gem install bundler -v 1.10.5
+notifications:
+  email: false

data/README.md

@@ -1,4 +1,4 @@
-**DON'T USE THIS YET**
+![travisci](https://travis-ci.org/abachman/diary-ruby.svg?branch=master)
 
 # diary-ruby
 

data/diary-ruby.gemspec

@@ -36,4 +36,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'rdiscount', '~> 2.1'
   spec.add_dependency 'slop', '~> 4.2'
   spec.add_dependency 'launchy', '~> 2.4'
+  spec.add_dependency 'sqlite3', '~> 1.3'
 end

data/exe/diaryrb

@@ -7,21 +7,23 @@ require 'thread'
 
 DEFAULT_DIARY = "diaryrb.store"
 
-prompt_for_password = false
+# prompt_for_password = false
 opts = Slop.parse do |o|
-  # o.string '-c', '--configuration', 'config file location'
   o.string '-d', '--diary', "choose diary storage file (leave blank for default, #{DEFAULT_DIARY})"
-  o.string '-p', '--passphrase', 'Use given encryption passphrase or prompt if option is used but no passphrase is given.', default: false do |v|
-    if v.start_with?('-') || v.nil? || v.strip.size == 0
-      prompt_for_password = true
-    end
-  end
+  # o.string '-c', '--configuration', 'config file location'
+  # o.string '-p', '--passphrase', 'Use given encryption passphrase or prompt if option is used but no passphrase is given.', default: false do |v|
+  #   if v.start_with?('-') || v.nil? || v.strip.size == 0
+  #     prompt_for_password = true
+  #   end
+  # end
 
   # usage modes
   o.separator ''
   o.separator "Actions (can't be used in combination):"
+  o.bool '-x', '--export', 'export all entries immediately to JSON'
   o.string '-e', '--edit', 'edit a specific post'
   o.bool '-l', '--list', 'list all posts by date'
+  o.string '-t', '--tag', 'list entries, filtered by tag'
   o.bool '-s', '--serve', 'start Diary webserver'
 
   o.separator ''
@@ -57,50 +59,50 @@ end
 
 Diary::Configuration.current_diary = _diary
 
-_passphrase = nil
-if prompt_for_password
-  require 'io/console'
-  print "Enter passphrase (leave blank for none): "
-  _passphrase = STDIN.noecho {|io| io.gets}.chomp
-elsif opts[:passphrase] && opts[:passphrase].strip.size > 0
-  _passphrase = opts[:passphrase]
-elsif ENV['PASSPHRASE']
-  _passphrase = ENV['PASSPHRASE']
-elsif Diary::Configuration.passphrase
-  _passphrase = Diary::Configuration.passphrase
-end
-
 diary_path = Diary::Configuration.path || Diary::Configuration.current_diary
-Diary.debug "LOADING DIARY #{ Diary::Configuration.current_diary } AT PATH #{ diary_path }"
-if _passphrase.nil? || _passphrase.size == 0
-  Diary.debug "LOADING WITH NO PASSPHRASE!"
-  $store = Diary::Store.new(diary_path)
-else
-  Diary.debug "LOADING WITH PASSPHRASE #{ _passphrase.gsub(/./, '*') }"
-  $store = Diary::SecureStore.new(diary_path, _passphrase)
-end
+database = Diary::Database.new(diary_path)
 
-# this is like rake db:migrate
-$store.write do |db|
-  db[:entries] ||= []
-  db[:entries] = db[:entries].compact.uniq.sort
-  db[:tags] ||= []
-end
+# make sure we're always up to date
+migrator = Diary::Migrator.new(database)
+migrator.migrate!
 
-if opts.list?
-  entries = $store.read(:entries)
+# initialize ORM
+Diary::Model.connection = database
+
+if opts.export?
   puts ''
 
-  if entries.nil? || entries.size == 0
+  if Diary::Entry.count == 0
     puts "No entries"
     exit
   else
-    entries.uniq.sort.reverse.each do |entry_key|
-      puts "#{ entry_key }   #{ $store.read(entry_key)[:text][0..40].gsub("\n", ' ') }..."
+    require 'json'
+
+    output = []
+
+    Diary::Entry.order('created_at DESC').each do |entry|
+      output << entry.to_hash
+    end
+
+    puts JSON.pretty_generate(output)
+  end
+elsif opts.list?
+  puts ''
+  if Diary::Entry.count == 0
+    puts "No entries"
+    exit
+  else
+    Diary::Entry.order('created_at DESC').each do |entry|
+      puts entry.summary
     end
   end
+elsif opts[:tag] && (tag_id = Diary::Model.select_value('select rowid from tags where name = ?', opts[:tag]))
+  entry_ids = Diary::Model.select_values('select entry_id from taggings where tag_id = ?', tag_id)
+  Diary::Entry.where(date_key: entry_ids).each do |entry|
+    puts entry.summary
+  end
 elsif opts.serve?
-  Diary::Server.store = $store
+  # Diary::Server.store = $store
   t = Thread.new do
     Diary::Server.run!
   end
@@ -114,7 +116,7 @@ else
 
   def parse_and_store(file)
     diary_entry = Diary::Parser.parse_file(file)
-    $store.write_entry(diary_entry)
+    diary_entry.save!
   end
 
   # create a tempfile to store entry in progress in EDITOR
@@ -127,18 +129,18 @@ else
     time: Time.now.strftime("%T"),
     tags: "",
     title: "",
-    text: "text goes here"
+    body: "text goes here"
   }
 
-  # if --edit option is used with a valid entry, load it
-  if opts[:edit] && (entry_hash = $store.read(opts[:edit]))
-    entry = Diary::Entry.from_store(entry_hash)
-    entry_source = entry.to_hash
-    entry_source[:tags] = entry_source[:tags].join(', ')
+  # # if --edit option is used with a valid entry, load it
+  if opts[:edit] && Diary::Entry.exists?(date_key: opts[:edit])
+    entry = Diary::Entry.find(date_key: opts[:edit])
+    entry_source = entry.to_hash if entry
+    # FIXME: set tags
   end
 
   # prepare entry and launch editor
-  tmpl = Diary::Entry.generate(entry_source, $store)
+  tmpl = Diary::Entry.generate(entry_source)
   file.write(tmpl)
 
   ed = "vim -f"
@@ -149,12 +151,17 @@ else
   end
 
   pid = fork do
-    exec("#{ ed } #{ file.path }")
+    # split the editor into a separate process
+    command = if /%s/ =~ ed
+                ed % [file.path]
+              else
+                "#{ ed } #{ file.path }"
+              end
+    exec(command)
   end
 
   # wait for child to finish, exit when the editor exits
   exit_signal = Queue.new
-
   trap("CLD") do
     Diary.log "CHILD PID #{pid} TERMINATED"
     exit_signal.push(true)

data/lib/diary-ruby.rb

@@ -1,6 +1,10 @@
 require "diary-ruby/version"
-require "diary-ruby/store"
-require "diary-ruby/entry"
+# require "diary-ruby/store"
+require "diary-ruby/database"
+require "diary-ruby/database/migrator"
+require "diary-ruby/database/query"
+require "diary-ruby/model"
+require "diary-ruby/models/entry"
 require "diary-ruby/parser"
 require "diary-ruby/configuration"
 require "diary-ruby/server/server"

data/lib/diary-ruby/database.rb

@@ -0,0 +1,22 @@
+require 'sqlite3'
+require 'diary-ruby/database/query'
+
+module Diary
+  class Database
+    attr_reader :database
+
+    def initialize(path)
+      @database = SQLite3::Database.new(path)
+    end
+
+    def execute(*query)
+      if block_given?
+        @database.execute(*query) do |row|
+          yield row
+        end
+      else
+        @database.execute(*query)
+      end
+    end
+  end
+end

data/lib/diary-ruby/database/migrator.rb

@@ -0,0 +1,90 @@
+MIGRATIONS = {}
+
+INITIALIZE = %[
+CREATE TABLE IF NOT EXISTS `versions` (
+  `version` TEXT NOT NULL,
+  `migrated_at` TEXT DEFAULT NULL
+);
+]
+
+## MIGRATION FORMAT:
+# MIGRATIONS[number] = array of sql statements
+
+# 001 - create initial tables
+MIGRATIONS['001'] = [%[
+  CREATE TABLE IF NOT EXISTS `entries` (
+    `date_key` TEXT NOT NULL PRIMARY KEY,
+    `day`  TEXT NOT NULL,
+    `time` TEXT NOT NULL,
+    `title` TEXT,
+    `link` TEXT,
+    `body` TEXT,
+    `created_at` TEXT NOT NULL,
+    `updated_at` TEXT DEFAULT NULL
+  );
+], %[
+  CREATE INDEX IF NOT EXISTS `index_entries_on_key` on `entries` (`date_key`);
+], %[
+  CREATE TABLE IF NOT EXISTS `tags` (
+    `name` TEXT DEFAULT NULL
+  );
+], %[
+  CREATE TABLE IF NOT EXISTS `taggings` (
+    `tag_id` INTEGER NOT NULL,
+    `entry_id` TEXT NOT NULL
+  );
+], %[
+  CREATE INDEX IF NOT EXISTS `index_taggings_on_tag_id` on `taggings` (`tag_id`);
+], %[
+  CREATE INDEX IF NOT EXISTS `index_taggings_on_entry_id` on `taggings` (`entry_id`);
+]]
+
+MIGRATION_VERSIONS = MIGRATIONS.keys.sort
+
+module Diary
+  class Migrator
+    attr_reader :db
+
+    def initialize(db)
+      @db = db.database
+    end
+
+    def migrate!
+      exists = false
+      db.execute( "SELECT name FROM sqlite_master WHERE type='table' AND name='versions';" ) do |row|
+        if row
+          exists = true
+        end
+      end
+
+      if !exists
+        db.execute(INITIALIZE)
+      end
+
+      MIGRATION_VERSIONS.each do |version|
+        exists = false
+        on_date = nil
+        db.execute( "select rowid, migrated_at from versions WHERE version = '#{version}'" ) do |row|
+          if row
+            exists = true
+            on_date = row[1]
+          end
+        end
+
+        if !exists
+          Diary.debug("UPDATING DATABASE TO VERSION #{ version }")
+          if MIGRATIONS[version].is_a?(Array)
+            MIGRATIONS[version].each do |statement|
+              db.execute(statement)
+            end
+          else
+            db.execute(MIGRATIONS[version])
+          end
+          db.execute("INSERT INTO versions VALUES ('#{version}', strftime('%Y-%m-%dT%H:%M:%S+0000'));")
+        else
+          Diary.debug("AT #{ version } SINCE #{ on_date }")
+        end
+      end
+    end
+  end
+end

data/lib/diary-ruby/database/query.rb

@@ -0,0 +1,269 @@
+
+module Diary
+  module Query
+    class Select
+      def initialize(table, context=nil)
+        @table_name = table
+        @context = context
+        @additions = []
+      end
+
+      def context
+        @context
+      end
+
+      ## evaluation conditions, called when Select is given a context
+      # FIXME: it's gross that Query::Select knows about Model
+
+      def execute_in_context(sql)
+        Diary.debug("[Query::Select execute_in_context] connection.execute(#{ sql.inspect })")
+        if Array === sql
+          context.connection.execute(*sql)
+        else
+          context.connection.execute(sql)
+        end
+      end
+
+      def first
+        return self unless context
+        result = execute_in_context(self.limit(1).to_sql)
+        context.materialize(result)[0]
+      end
+
+      def all
+        return self unless context
+        result = execute_in_context(self.to_sql)
+        context.materialize(result)
+      end
+
+      def each(&block)
+        return self unless context
+        result = execute_in_context(self.to_sql)
+        context.materialize(result).each(&block)
+      end
+
+      def map(&block)
+        return self unless context
+        result = execute_in_context(self.to_sql)
+        context.materialize(result).map(&block)
+      end
+
+      def size
+        return self unless context
+        result = execute_in_context(self.to_sql)
+        result.size
+      end
+      alias :count :size
+
+      ##
+
+      def select(column_query)
+        @column_query = column_query
+      end
+
+      def exists?(*conditions)
+        if conditions.size > 0
+          @additions = []
+          @additions << Where.new(*conditions)
+          @additions << Limit.new(1)
+        end
+        c = self.count
+        c && c > 0
+      end
+
+      def where(*conditions)
+        # multiple wheres are OR'd
+        @additions << Where.new(*conditions)
+        self
+      end
+
+      def order(*conditions)
+        @additions << Order.new(*conditions)
+        self
+      end
+
+      def limit(*conditions)
+        @additions << Limit.new(*conditions)
+        self
+      end
+
+      def group_by(*conditions)
+        @additions << GroupBy.new(*conditions)
+        self
+      end
+
+      def to_sql
+        # combine @additions in order: WHERE () GROUP BY () ORDER () LIMIT ()
+
+        sql_string = []
+        bind_vars = []
+
+        wheres = @additions.select {|a| Where === a}
+        group_bys = @additions.select {|a| GroupBy === a}
+        orders = @additions.select {|a| Order === a}
+        limits = @additions.select {|a| Limit === a}
+
+        if wheres.size > 0
+          sql_string << "WHERE"
+
+          where_params = []
+
+          wheres = wheres.each do |w|
+            if w.has_bound_vars?
+              bind_vars << w.prepared_statement.bind_vars
+            end
+
+            where_params << w.prepared_statement.sql_string
+          end
+
+          sql_string << where_params.map {|wp|
+            "(#{ wp })"
+          }.join(' OR ')
+        end
+
+        if group_bys.size > 0
+          sql_string << "GROUP BY #{group_bys.map {|gb| gb.prepared_statement.sql_string}.join(', ')}"
+        end
+
+        if orders.size > 0
+          sql_string << "ORDER BY #{orders.map {|ord| ord.prepared_statement.sql_string}.join(', ')}"
+        end
+
+        if limits.size > 0
+          # only 1 allowed, last takes precedence
+          limit = limits.last
+          sql_string << "LIMIT #{limit.prepared_statement.sql_string}"
+        end
+
+        query = [
+          "SELECT #{ @column_query || '*' }",
+          "FROM `#{ @table_name }`",
+          sql_string
+        ].join(' ')
+
+        # once to_sql is called, the Query is reset
+        @additions = []
+
+        # return sqlite compatible SQL
+        returning = if bind_vars.size > 0
+                      [query, bind_vars.flatten]
+                    else
+                      query
+                    end
+        returning
+      end
+    end
+
+    class SQLBoundParams
+      def initialize(left, right)
+        @for_sql_query = [left, right]
+      end
+
+      def sql_string
+        @for_sql_query[0]
+      end
+
+      def bind_vars
+        @for_sql_query[1]
+      end
+    end
+
+    class SQLString
+      def initialize(value)
+        @for_sql_query = value
+      end
+
+      def sql_string
+        @for_sql_query
+      end
+    end
+
+    class Node
+      def string_or_symbol?(value)
+        String === value || Symbol === value
+      end
+
+      def prepared_statement
+        @sql_result
+      end
+
+      def has_bound_vars?
+        SQLBoundParams === prepared_statement
+      end
+    end
+
+    class Where < Node
+      # convert conditions to AND'd list
+      # returns either string or (string, bind_params) 2-tuple
+      def initialize(*conditions)
+        @sql_result = if Hash === conditions[0]
+                        attrs = conditions[0]
+
+                        keys = attrs.keys
+                        vals = keys.map {|k| attrs[k]}
+
+                        and_string = keys.map do |k|
+                          if attrs[k].is_a?(Array)
+                            bind_hold = attrs[k].map {|_| '?'}.join(',')
+                            "`#{k}` in (#{bind_hold})"
+                          else
+                            "`#{k}` = ?"
+                          end
+                        end.join(' AND ')
+
+                        # (string, bind)
+                        SQLBoundParams.new(and_string, vals.flatten)
+                      elsif conditions.size > 1 && String === conditions[0]
+                        # assume (string, bind) given
+                        SQLBoundParams.new(conditions[0], conditions[1..-1])
+                      elsif conditions.size == 1 && String === conditions[0]
+                        SQLString.new(conditions[0])
+                      end
+      end
+    end
+
+    class Order < Node
+      def initialize(*conditions)
+        sql_string = if conditions.size == 1
+                       if string_or_symbol?(conditions[0])
+                         conditions[0]
+                       elsif Array === conditions[0]
+                         conditions.join(', ')
+                       else
+                         conditions[0].to_s
+                       end
+                     elsif conditions.size > 1
+                       conditions.join(', ')
+                     end
+
+        @sql_result = SQLString.new(sql_string)
+      end
+    end
+
+    class Limit < Node
+      def initialize(*conditions)
+        sql_string = if conditions.size == 1
+                       conditions[0]
+                     elsif conditions.size > 1
+                       conditions.join(', ')
+                     end
+        @sql_result = SQLString.new(sql_string)
+      end
+    end
+
+    class GroupBy < Node
+      def initialize(*conditions)
+        sql_string = if conditions.size == 1
+                       conditions[0]
+                     elsif conditions.size > 1
+                       conditions.join(', ')
+                     end
+        @sql_result = SQLString.new(sql_string)
+      end
+    end
+
+    # class Table
+    #   extend Select
+    # end
+  end
+end

data/lib/diary-ruby/ext/concern.rb

@@ -0,0 +1,166 @@
+# taken from: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/concern.rb
+#
+# Copyright (c) 2005-2016 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+module ActiveSupport
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     class_methods do
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
+  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # It works, now Bar takes care of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        raise MultipleIncludedBlocks if instance_variable_defined?(:@_included_block)
+
+        @_included_block = block
+      else
+        super
+      end
+    end
+
+    def class_methods(&class_methods_module_definition)
+      mod = const_defined?(:ClassMethods, false) ?
+        const_get(:ClassMethods) :
+        const_set(:ClassMethods, Module.new)
+
+      mod.module_eval(&class_methods_module_definition)
+    end
+  end
+end
+

data/lib/diary-ruby/model.rb

@@ -0,0 +1,98 @@
+require 'diary-ruby/ext/concern'
+
+module Diary
+  module ModelQuery
+    extend ActiveSupport::Concern
+
+    # Instance Methods
+    def timestamp_sql
+      "strftime('%Y-%m-%dT%H:%M:%S+0000')"
+    end
+
+    module ClassMethods
+      def columns
+        @columns ||= connection.execute("PRAGMA table_info(#{table_name})")
+      end
+
+      def column_names
+        @column_names ||= columns.map {|col_info| col_info[1]}
+      end
+
+      def results_to_hashes(array_of_rows)
+        array_of_rows.map do |row|
+          Hash[ column_names.zip(row) ]
+        end
+      end
+
+      def materialize(array_of_rows)
+        results_to_hashes(array_of_rows).map do |record_hash|
+          if respond_to?(:from_hash)
+            from_hash(record_hash)
+          else
+            record_hash
+          end
+        end
+      end
+
+      def find(attrs)
+        where(attrs).first
+      end
+
+      def new_select_relation
+        Diary::Query::Select.new(table_name, self)
+      end
+
+      %w(where order group_by limit exists?).each do |q_type|
+        define_method(q_type.to_sym) do |*conditions|
+          new_select_relation.send(q_type.to_sym, *conditions)
+        end
+      end
+
+      %w(all first count).each do |q_type|
+        define_method(q_type.to_sym) do
+          new_select_relation.send(q_type.to_sym)
+        end
+      end
+
+      %w(each map).each do |q_type|
+        define_method(q_type.to_sym) do |&block|
+          new_select_relation.send(q_type.to_sym, &block)
+        end
+      end
+
+    end
+  end
+
+  class Model
+    include ModelQuery
+
+    class << self
+      def connection=(db)
+        @@connection = db
+      end
+
+      def connection
+        @@connection
+      end
+
+      # one-off queries
+      def execute(sql, *binds)
+        Diary.debug("[Model execute] #{ sql } #{ binds.inspect }")
+        connection.execute(sql, binds)
+      end
+
+      # one-off queries
+      def select_rows(sql, *binds)
+        execute(sql, *binds)
+      end
+
+      def select_values(sql, *binds)
+        select_rows(sql, *binds).map {|row| row[0]}
+      end
+
+      def select_value(sql, *binds)
+        select_values(sql, *binds).first
+      end
+    end
+  end
+end

data/lib/diary-ruby/models/entry.rb

@@ -0,0 +1,151 @@
+TEMPLATE = "# last entry posted at %{last_update_at}
+
+DAY   %{day}
+TIME  %{time}
+TAGS  %{tags}
+TITLE %{title}
+
+---
+
+%{body}
+"
+
+require 'rdiscount'
+require 'diary-ruby/model'
+
+module Diary
+  class Entry < Model
+    attr_accessor :day, :time, :tags, :body, :link, :title, :date_key
+
+    def self.table_name
+      'entries'
+    end
+
+    def self.from_hash(record)
+      entry = self.new(
+        day: record['day'],
+        time: record['time'],
+        body: record['body'],
+        title: record['title'],
+        date_key: record['date_key'],
+      )
+
+      # taggings!
+      begin
+        tag_ids = select_values('select tag_id from taggings where entry_id = ?', [entry.identifier])
+        bind_hold = tag_ids.map {|_| '?'}.join(',')
+        entry.tags = select_values("select name from tags where rowid in (#{ bind_hold })", *tag_ids)
+      rescue => ex
+        Diary.debug "FAILED TO LOAD TAGS. #{ ex.message }"
+      end
+
+      entry
+    end
+
+    def self.keygen(day, time)
+      "%s-%s" % [day, time]
+    end
+
+    def self.generate(options={})
+      options[:last_update_at] = connection.execute("select max(updated_at) from #{table_name}")[0] || ''
+
+      # convert Arrays to dumb CSV
+      options.each do |(k, v)|
+        if v.is_a?(Array)
+          options[k] = v.join(', ')
+        end
+      end
+
+      TEMPLATE % options
+    end
+
+    def initialize(options={})
+      @day = options[:day]
+      @time = options[:time]
+      @tags = options[:tags] || []
+      @body = options[:body]
+      @title = options[:title]
+
+      if options[:date_key].nil?
+        @date_key = identifier
+      else
+        @date_key = options[:date_key]
+      end
+    end
+
+    def identifier
+      self.class.keygen(day, time)
+    end
+
+    def formatted_body
+      RDiscount.new(body).to_html
+    end
+
+    def truncated_body
+      _truncated = body
+      if _truncated.size > 40
+        _truncated = "#{ _truncated[0..40] }..."
+      end
+      _truncated
+    end
+
+    def summary
+      "%-24s%-46s%s" % [date_key, truncated_body, tags.join(', ')]
+    end
+
+    def to_hash
+      {
+        day: day,
+        time: time,
+        tags: tags,
+        body: body,
+        title: title,
+        date_key: date_key,
+      }
+    end
+
+    def save!
+      if self.class.find(date_key: date_key)
+        # update record
+        sql = "UPDATE entries SET day=?, time=?, body=?, link=?, title=?, updated_at=#{timestamp_sql} WHERE date_key=?"
+        self.class.execute(sql, day, time, body, link, title, date_key)
+      else
+        # insert
+        sql = %[INSERT INTO entries (day, time, body, link, title, date_key, created_at, updated_at)
+                VALUES              (?,   ?,    ?,    ?,    ?,     ?,        #{timestamp_sql}, #{timestamp_sql})]
+        self.class.execute(sql, day, time, body, link, title, date_key)
+      end
+
+      begin
+        update_tags!
+      rescue => ex
+        Diary.debug "FAILED TO UPDATE TAGS #{ tags.inspect }. #{ ex.message }"
+      end
+    end
+
+    def update_tags!
+      # clean out existing
+      Diary.debug "CLEANING `taggings`"
+      self.class.execute('delete from taggings where entry_id = ?', [identifier])
+
+      # add back
+      tags.each do |tag|
+        # is tag in db?
+        tag_id = self.class.select_value('select rowid from tags where name = ?', tag)
+
+        if tag_id.nil?
+          Diary.debug "CREATING TAG #{ tag.inspect }"
+
+          # exists
+          Diary.debug self.class.select_rows('PRAGMA table_info(tags)').inspect
+          self.class.execute("insert into tags (name) values (?)", [tag])
+          tag_id = self.class.select_value('select last_insert_rowid()')
+        end
+
+        Diary.debug "CREATING tagging"
+        self.class.execute('insert into taggings (tag_id, entry_id) values (?, ?)', [tag_id, identifier])
+      end
+    end
+  end
+end
+

data/lib/diary-ruby/parser.rb

@@ -46,11 +46,10 @@ module Diary
       Diary.debug "BODY #{ body.join(" ") }"
 
       return Entry.new(
-        nil,
         day: metadata['day'],
         time: metadata['time'],
         tags: metadata['tags'],
-        text: body.join("\n").strip,
+        body: body.join("\n").strip,
         title: metadata['title'],
         key: key,
       )

data/lib/diary-ruby/server/server.rb

@@ -22,27 +22,10 @@ module Diary
     end
 
     get '/' do
-      keys = store.read(:entries)
-
-      if keys.nil?
-        store.write do |db|
-          db[:entries] = []
-        end
-
-        keys = []
+      @entries = Entry.order('created_at DESC').map do |entry_hash|
+        Entry.from_hash(entry_hash)
       end
 
-      @entries = keys.uniq.map {|entry_key|
-        entry = store.read(entry_key)
-
-        if entry
-          logger.debug "LOAD #{ entry }"
-          Entry.from_store(entry)
-        else
-          nil
-        end
-      }.compact
-
       logger.info "returning keys: #{ keys }"
       logger.info "returning entries: #{ @entries }"
 
@@ -53,16 +36,13 @@ module Diary
       content_type :json
 
       key = params[:key]
-      entry_hash = store.read(key)
-      entry = Entry.from_store(entry_hash)
-
-      content = RDiscount.new entry.text
-      entry_hash[:formatted] = content.to_html
+      entry_hash = Entry.find(date_key: key)
 
-      if entry
+      if entry_hash
+        entry = Entry.from_store(entry_hash)
+        content = RDiscount.new entry['body']
+        entry_hash[:formatted] = content.to_html
         entry_hash.to_json
-      else
-        {}
       end
     end
 
@@ -81,7 +61,7 @@ module Diary
         day: params[:day],
         time: params[:time],
         tags: tags,
-        text: params[:text],
+        body: params[:body],
       )
 
       store.write_entry(entry)

data/lib/diary-ruby/server/views/index.erb

@@ -45,7 +45,7 @@
 
         <label>
           <span>Text</span>
-          <textarea class='text' name='text'></textarea>
+          <textarea class='text' name='body'></textarea>
         </label>
 
         <input type='submit' value='commit' />

data/lib/diary-ruby/version.rb

@@ -1,3 +1,3 @@
 module Diary
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: diary-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Adam Bachman
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-07 00:00:00.000000000 Z
+date: 2016-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: 'A command line diary: diaryrb'
 email:
 - adam.bachman@gmail.com
@@ -144,9 +158,14 @@ files:
 - exe/diaryrb
 - lib/diary-ruby.rb
 - lib/diary-ruby/configuration.rb
-- lib/diary-ruby/entry.rb
+- lib/diary-ruby/database.rb
+- lib/diary-ruby/database/migrator.rb
+- lib/diary-ruby/database/query.rb
+- lib/diary-ruby/ext/concern.rb
 - lib/diary-ruby/ext/encryptor.rb
 - lib/diary-ruby/ext/secure_pstore.rb
+- lib/diary-ruby/model.rb
+- lib/diary-ruby/models/entry.rb
 - lib/diary-ruby/parser.rb
 - lib/diary-ruby/server/public/script.js
 - lib/diary-ruby/server/public/style.css

data/lib/diary-ruby/entry.rb

@@ -1,85 +0,0 @@
-TEMPLATE = "# last entry posted at %{last_update_at}
-
-DAY   %{day}
-TIME  %{time}
-TAGS  %{tags}
-TITLE %{title}
-
----
-
-%{text}
-"
-
-require 'rdiscount'
-
-module Diary
-  class Entry
-    attr_accessor :version, :day, :time, :tags, :text, :title, :key
-
-    CURRENT_VERSION = 1
-
-    def self.from_store(record)
-      if record[:version] == 1
-        self.new(
-          record[:version],
-          day: record[:day],
-          time: record[:time],
-          tags: record[:tags],
-          text: record[:text],
-          title: record[:title],
-          key: record[:key],
-        )
-      end
-    end
-
-    def self.keygen(day, time)
-      "%s-%s" % [day, time]
-    end
-
-    def self.generate(options={}, store)
-      options[:last_update_at] = store.read(:last_update_at)
-
-      # convert Arrays to dumb CSV
-      options.each do |(k, v)|
-        if v.is_a?(Array)
-          options[k] = v.join(', ')
-        end
-      end
-
-      TEMPLATE % options
-    end
-
-    def initialize(version, options={})
-      @version = version || CURRENT_VERSION
-
-      @day = options[:day]
-      @time = options[:time]
-      @tags = options[:tags] || []
-      @text = options[:text]
-      @title = options[:title]
-
-      if options[:key].nil?
-        @key = Entry.keygen(day, time)
-      else
-        @key = options[:key]
-      end
-    end
-
-    def formatted_text
-      RDiscount.new(text).to_html
-    end
-
-    def to_hash
-      {
-        version: version,
-        day: day,
-        time: time,
-        tags: tags,
-        text: text,
-        title: '',
-        key: key,
-      }
-    end
-  end
-end
-