sgfa 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d45c0bbd41d4e9b39a6c9b13f47fff3e0b2de18e
-  data.tar.gz: 47f07e0899c32bff1374af1e0529d70e5f508221
+  metadata.gz: e56f45ef9e949c37978cee9dfc394769eeb6baa2
+  data.tar.gz: c4be3d1955e1700dcfa59c02a75cc6259c9ed3b0
 SHA512:
-  metadata.gz: 3347b66a768fae632d618c35656b70e813fb1ff8ca5cc207dfb074acfc4c7e85f414115c7d4cc343ac9c185420177f55c9d6624cd4890c7821c52b09056c7ef3
-  data.tar.gz: 34e8c399c39e436150091609fb0a4ac7c7d53869fe16f7b5b8903e81f5414d69989d6ec96a09efcd3bda0ef70d3fd02d2980d96c5eef25118161fc8b43c1aa7d
+  metadata.gz: 5e888580f637df355364aad7e997e1d3c548693bf584f7eaedec7fdc3cefd72b195117d9d8a87073866f545f28ad11dc7cbfe5f4f2b5348a1522feea7e68cc25
+  data.tar.gz: 9df09e1204ae56856b24bf30ad6075be1bbad8728ae38bfde47487f21c01c313cbbeead33cf8e07c08d61e6e57d2f1630f1ab708c15d310bfaa289a69e8f9a0d

data/data/sgfa_web.css

@@ -119,7 +119,17 @@ div#sgfa_web table.list td.hash {
 }
 
 
-/* edit tables */
+/* edit */
+div#sgfa_web form.edit input {
+  font-family: inherit;
+  font-size: inherit;
+}
+
+div#sgfa_web form.edit textarea {
+  font-family: inherit;
+  font-size: inherit;
+}
+
 div#sgfa_web form.edit fieldset {
   width: 98%;
   margin: auto;
@@ -130,40 +140,12 @@ div#sgfa_web form.edit fieldset legend {
   font-weight: bold;
 }
 
-div#sgfa_web form.edit p {
-  clear: both;
-  padding: 3px;
-}
-
 div#sgfa_web form.edit label {
   float: left;
   width: 8em;
   text-align: right;
 }
 
-/* edit tag table */
-div#sgfa_web table.edit_tag th {
-  text-align: center;
-  text-decoration: underline;
-}
-
-div#sgfa_web table.edit_tag tr {
-  border: thick solid red;
-}
-
-
-/* edit file table */
-div#sgfa_web table.edit_file th {
-  text-align: center;
-  text-decoration: underline;
-}
-
-div#sgfa_web table.edit_file td.fname {
-  min-width: 10em;
-}
-
-
-/* edit form */
 div#sgfa_web form.edit input[type=submit] {
   border: 1px solid grey;
   border-radius: 5px;
@@ -172,22 +154,30 @@ div#sgfa_web form.edit input[type=submit] {
 }
 
 div#sgfa_web form.edit textarea {
-  font-family: inherit;
-  font-size: inherit;
   width: 50em;
   height: 15em;
 }
 
 div#sgfa_web form.edit input.title {
-  font-family: inherit;
-  font-size: inherit;
   width: 50em;
 }
 
+div#sgfa_web form.edit input.attname {
+  width: 30em;
+}
+
 div#sgfa_web form.edit input.tag {
-  width: 15em;
+  width: 30em;
 }
 
+div#sgfa_web form.edit button.add_row {
+  border: 1px solid grey;
+  border-radius: 5px;
+  padding: 2px;
+  background: radial-gradient(rgb(245, 245, 245), rgb(200, 200, 200));
+}
+
+
 
 /* entry */
 div#sgfa_web div.entry_left {
@@ -195,6 +185,17 @@ div#sgfa_web div.entry_left {
   width: 80%;
 }
 
+div#sgfa_web div.mainbody div.pages {
+  width: 100%;
+  border-top: 2px solid;
+}
+
+div#sgfa_web div.mainbody div.tagname {
+  width: 100%;
+  font-size: 150%;
+  border-bottom: 2px solid;
+}
+
 div#sgfa_web div.mainbody div.title {
   width: 100%;
   font-size: 125%;
@@ -225,6 +226,7 @@ div#sgfa_web div.mainbody div.sidebar div.tags {
 }
 
 div#sgfa_web div.attach {
+  border-bottom: thin solid;
 }
 
 div#sgfa_web div.mainbody div.sidebar div.user {
@@ -235,6 +237,7 @@ div#sgfa_web div.hash {
   width: 100%;
   clear: both;
   border-top: thin solid;
+  padding-bottom: 3px;
   font-family: monospace;
   font-size: 75%;
 }

data/lib/sgfa/binder.rb

@@ -285,12 +285,28 @@ class Binder
   # @param tag [String] Tag name
   # @param offs [Integer] Offset to begin reading
   # @param max [Integer] Maximum number of entries to read
-  def read_tag(tr, tag, offs, max)
+  # @param opts [Hash] Options hash
+  # @option opts [Boolean] :raw Get the raw entry when permissions allow
+  # @return [Array] \[ enum, rnum, hnum, time, title, num_tags, num_attach,
+  #   \] Or, if opts[:raw], each Array item will consist of the Entry or,
+  #   if user does not have read permission, the info array.
+  def read_tag(tr, tag, offs, max, opts={})
+    raw = opts[:raw]
     _jacket(tr, 'read') do |jck|
       size, ents = jck.read_tag(tag, offs, max)
       lst = ents.map do |ent|
-        [ent.entry, ent.revision, ent.time, ent.title, ent.tags.size,
-          ent.attachments.size]
+        if raw
+          pl = ent.perms
+          begin
+            _perms(tr, pl)
+            item = ent
+          rescue Error::Permission
+            item = nil
+          end
+        end
+        item ||= [ent.entry, ent.revision, ent.history, ent.time, ent.title,
+          ent.tags.size, ent.attachments.size]
+        item
       end
       [size, lst]
     end
@@ -398,9 +414,195 @@ class Binder
   end # def write()
 
 
+  #########################################################
+  # @!group Backup
+
+
+  #####################################
+  # Push to a backup store
+  #
+  # @param bsto [Store] Backup store
+  # @param opts [Hash] Options
+  # @option opts [Hash] :log The log.  Defaults to STDERR at warn level.
+  # @option opts [Hash] :prev Jacket id_hash to previously pushed max history
+  # @return [Hash] Jacket id_hash to max history backed up
+  def backup_push(bsto, opts={})
+
+    stat = {}
+    prev = opts[:prev] || {}
+    log = opts[:log]
+    if !log
+      log = Logger.new(STDERR)
+      log.level = Logger::WARN
+    end
+    
+    # control jacket push
+    jcks = nil
+    _shared do
+      ctl = _jacket_open(0)
+      begin
+        min = (prev[@id_hash] || 0) + 1
+        log.info('Backup push control %s at %d' % [@id_hash, min])
+        stat[@id_hash] = ctl.backup(bsto, min_history: min, log: log)
+      ensure
+        ctl.close
+      end
+      jcks = @jackets.values
+    end
+
+    # all other jackets
+    jcks.each do |info|
+      jck = _jacket_open(info[:num])
+      begin
+        id = info[:id_hash]
+        min = (prev[id] || 0) + 1
+        log.info('Backup push jacket %s at %d' % [id, min])
+        stat[id] = jck.backup(bsto, min_history: min, log: log)
+      ensure
+        jck.close
+      end
+    end
+
+    return stat
+  end # def backup_push()
+
+
+  #####################################
+  # Pull from backup store
+  #
+  # @param bsto [Store] Backup store
+  # @param opts [Hash] Options
+  # @option opts [Hash] :log The log.  Defaults to SDTERR at warn level
+  def backup_pull(bsto, opts={})
+
+    log = opts[:log]
+    if !log
+      log = Logger.new(STDERR)
+      log.level = Logger::WARN
+    end
+
+    @lock.do_ex do
+
+      # control jacket
+      ctl = _jacket_open(0)
+      begin
+        log.info('Backup pull control %s' % @id_hash)
+        ctl.restore(bsto, log: log)
+        log.info('Backup pull update cache state')
+        _update(ctl)
+      ensure
+        ctl.close()
+      end
+      _cache_write()
+
+      # all other jackets
+      @jackets.values.each do |info|
+        begin
+          jck = _jacket_open(info[:num])
+        rescue Error::NonExistent
+          log.info('Backup pull create jacket %s' % info[:id_hash])
+          _jacket_create_raw(info)
+          jck = _jacket_open(info[:num])
+        end
+        begin
+          log.info('Backup pull jacket %s' % info[:id_hash])
+          jck.restore(bsto, log: log)
+        ensure
+          jck.close
+        end
+      end
+
+    end 
+
+  end # def backup_pull()
+
+
   private
 
 
+  #####################################
+  # Update cache
+  def _update(ctl)
+
+    values = {}
+    users = {}
+    jackets = {}
+
+    ctl.read_list.each do |tag|
+
+      # values
+      if tag == 'values'
+
+        # process all values entries
+        offs = 0
+        while true
+          size, ary = ctl.read_tag(tag, offs, 2)
+          break if ary.empty?
+          ary.each do |ent|
+            info = _get_json(ent)
+            info.each do |val, sta|
+              next if values.has_key?(val)
+              values[val] = sta
+            end
+          end
+          offs += 2
+        end
+
+        # clear unset values
+        values.delete_if{ |val, sta| !sta.is_a?(String) }
+
+      # jacket
+      elsif /^jacket:/.match(tag)
+        size, ary = ctl.read_tag(tag, 0, 1)
+        info = _get_json(ary.first)
+        jackets[info['name']] = {
+          num: info['num'],
+          name: info['name'],
+          id_hash: info['id_hash'],
+          id_text: info['id_text'],
+          title: info['title'],
+          perms: info['perms'],
+        }
+
+      # user
+      elsif /^user:/.match(tag)
+        size, ary = ctl.read_tag(tag, 0, 1)
+        info = _get_json(ary.first)
+        name = info['name']
+        perms = info['perms']
+        users[name] = perms
+
+      end
+    end
+
+    @users = users
+    @values = values
+    @jackets = jackets
+
+  end # def _update()
+
+
+  #####################################
+  # Get json from a body
+  def _get_json(ent)
+    lines = ent.body.lines
+    st = lines.index{|li| li[0] == '{' || li[0] == '[' }
+    if !st || (lines[-1][0] != '}' && lines[-1][0] != ']')
+      puts ent.body.inspect
+      raise Error::Corrupt, 'Control jacket entry does not contain JSON'
+    end 
+    json = lines[st..-1].join
+
+    info = nil
+    begin
+      info = JSON.parse(json)
+    rescue
+      raise Error::Corrupt, 'Control jacket entry JSON parse error'
+    end
+    return info
+  end # def _get_json()
+
+
   #####################################
   # Shared creation stuff
   #

data/lib/sgfa/binder_fs.rb

@@ -26,16 +26,15 @@ module Sgfa
 class BinderFs < Binder
 
   #####################################
-  # Create a new binder
+  # Create a raw binder
+  #
+  # @note You almost certainly want to use {#create} not this method
   #
   # @param path [String] Path to the binder
-  # @param tr (see Binder#jacket_create)
-  # @param init [Hash] The binder initialization options
-  # @return [String] The hash ID of the new binder
-  def create(path, tr, init)
-    raise Error::Sanity, 'Binder already open' if @path
-    Binder.limits_create(init)
-
+  # @param id_text [String] The text ID
+  # @return [String] The hash ID
+  def create_raw(path, id_text)
+    
     # create directory
     begin
       Dir.mkdir(path)
@@ -45,8 +44,45 @@ class BinderFs < Binder
 
     # create control binder
     dn_ctrl = File.join(path, '0')
-    id_hash = JacketFs.create(dn_ctrl, init[:id_text])
-    jck = JacketFs.new(dn_ctrl)
+    id_hash = JacketFs.create(dn_ctrl, id_text)
+
+    # write info
+    info = {
+      'sgfa_binder_ver' => 1,
+      'id_hash' => id_hash,
+      'id_text' => id_text,
+    }
+    json = JSON.pretty_generate(info) + "\n"
+    fn_info = File.join(path, 'sgfa_binder.json')
+    File.open(fn_info, 'w', :encoding => 'utf-8'){|fi| fi.write json }
+    
+    # create empty cache
+    @path = path
+    @id_hash = id_hash
+    @jackets = {}
+    @users = {}
+    @values = {}
+    _cache_write
+    @path = nil
+    @id_hash = nil
+
+    return id_hash    
+  end # def create_raw()
+
+
+  #####################################
+  # Create a new binder
+  #
+  # @param path [String] Path to the binder
+  # @param tr (see Binder#jacket_create)
+  # @param init [Hash] The binder initialization options
+  # @return [String] The hash ID of the new binder
+  def create(path, tr, init)
+    raise Error::Sanity, 'Binder already open' if @path
+    Binder.limits_create(init)
+
+    # create completely empty binder
+    id_hash = create_raw(path, init[:id_text])
 
     # do the common creation
     @path = path
@@ -54,22 +90,13 @@ class BinderFs < Binder
     @jackets = {}
     @users = {}
     @values = {}
+    jck = _jacket_open(0)
     _create(jck, tr, init)
     jck.close
     _cache_write
     @path = nil
     @id_hash = nil
 
-    # write info
-    info = {
-      'sgfa_binder_ver' => 1,
-      'id_hash' => id_hash,
-      'id_text' => init[:id_text],
-    }
-    json = JSON.pretty_generate(info) + "\n"
-    fn_info = File.join(path, 'sgfa_binder.json')
-    File.open(fn_info, 'w', :encoding => 'utf-8'){|fi| fi.write json }
-    
     return id_hash
   end # def create()
 
@@ -143,6 +170,14 @@ class BinderFs < Binder
   end # def _jacket_create()
 
 
+  #####################################
+  # Create a jacket from backup
+  def _jacket_create_raw(info)
+    jp = File.join(@path, info[:num].to_s)
+    JacketFs.create_raw(jp, info[:id_text], info[:id_hash])
+  end # def _jacket_create_raw()
+
+
   #####################################
   # Open a jacket
   def _jacket_open(num)