Rufus::Cloche

# File lib/rufus/cloche.rb, line 64
def initialize (opts={})

  @dir = File.expand_path(opts[:dir] || 'cloche')
  @mutex = Mutex.new

  @nolock = WIN || opts[:nolock]
end

# File lib/rufus/cloche.rb, line 248
def self.neutralize (s)

  s.to_s.strip.gsub(/[ \/:;\*\\\+\?]/, '_')
end

# File lib/rufus/cloche.rb, line 137
def delete (doc)

  drev = doc['_rev']

  raise ArgumentError.new('cannot delete doc without _rev') unless drev

  type, key = doc['type'], doc['_id']

  r = lock(false, type, key) do |f|

    cur = do_get(f)

    return nil unless cur
    return cur if cur['_rev'] != drev

    begin
      f.close
      File.delete(f.path)
      nil
    rescue Exception => e
      #p e
      false
    end
  end

  r == false ? true : nil
end

# File lib/rufus/cloche.rb, line 119
def get (type, key)

  r = lock(false, type, key) { |f| do_get(f) }

  r == false ? nil : r
end

# File lib/rufus/cloche.rb, line 178
def get_many (type, key_match=nil, opts={})

  opts = opts.inject({}) { |h, (k, v)| h[k.to_s] = v; h }

  d = dir_for(type)

  return [] unless File.exist?(d)

  docs = []
  limit = opts['limit']

  files = Dir[File.join(d, '**', '*.json')].sort { |p0, p1|
    File.basename(p0) <=> File.basename(p1)
  }

  files.each do |fn|

    key = File.basename(fn, '.json')

    if (not key_match) || key.match(key_match)

      doc = get(type, key)
      docs << doc if doc

      break if limit && (docs.size >= limit)
    end
  end

  # WARNING : there is a twist here, the filenames may have a different
  #           sort order from actual _ids...

  #docs.sort { |doc0, doc1| doc0['_id'] <=> doc1['_id'] }
    # let's trust filename order

  docs
end

# File lib/rufus/cloche.rb, line 226
def ids (type)

  Dir[File.join(dir_for(type), '**', '*.json')].collect { |p|
    File.basename(p, '.json')
  }.sort
end

# File lib/rufus/cloche.rb, line 217
def purge_type! (type)

  FileUtils.rm_rf(dir_for(type))
end

# File lib/rufus/cloche.rb, line 83
def put (doc, opts={})

  opts = opts.inject({}) { |h, (k, v)| h[k.to_s] = v; h }

  doc = Rufus::Json.dup(doc) unless opts['update_rev']
    # work with a copy, don't touch original

  type, key = doc['type'], doc['_id']

  raise(
    ArgumentError.new("missing values for keys 'type' and/or '_id'")
  ) if type.nil? || key.nil?

  rev = (doc['_rev'] ||= -1)

  raise(
    ArgumentError.new("values for '_rev' must be positive integers")
  ) if rev.class != Fixnum && rev.class != Bignum

  lock(true, type, key) do |file|

    cur = do_get(file)

    return cur if cur && cur['_rev'] != doc['_rev']
    return true if cur.nil? && doc['_rev'] != -1

    doc['_rev'] = doc['_rev'] + 1

    File.open(file.path, 'wb') { |io| io.write(Rufus::Json.encode(doc)) }
  end

  nil
end

# File lib/rufus/cloche.rb, line 237
def real_ids (type)

  Dir[File.join(dir_for(type), '**', '*.json')].inject([]) { |a, p|
    doc = do_get(p)
    a << doc['_id'] if doc
    a
  }.sort
end

# File lib/rufus/cloche.rb, line 259
def dir_for (type)

  File.join(@dir, Cloche.neutralize(type || 'no_type'))
end

# File lib/rufus/cloche.rb, line 253
def do_get (file)

  s = file.is_a?(File) ? file.read : File.read(file)
  Rufus::Json.decode(s) rescue nil
end

# File lib/rufus/cloche.rb, line 273
def lock (create, type, key, &block)

  @mutex.synchronize do
    begin

      d, f = path_for(type, key)
      fn = File.join(d, f)

      if create && ( ! File.exist?(fn))
        FileUtils.mkdir_p(d) unless File.exist?(d)
        FileUtils.touch(fn) unless File.exist?(fn)
      end

      file = File.new(fn) rescue nil

      return false if file.nil?

      file.flock(File::LOCK_EX) unless @nolock
      block.call(file)

    ensure
      begin
        file.flock(File::LOCK_UN) unless @nolock
      rescue Exception => e
        #p [ :lock, @fpath, e ]
        #e.backtrace.each { |l| puts l }
      end
      begin
        file.close if file
      rescue Exception => e
        #p [ :close_fail, e ]
      end
    end
  end
end

# File lib/rufus/cloche.rb, line 264
def path_for (type, key)

  nkey = Cloche.neutralize(key)

  subdir = (nkey[-2, 2] || nkey).gsub(/\./, 'Z')

  [ File.join(dir_for(type), subdir), "#{nkey}.json" ]
end