tmsu_file_db 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 910c386ec16296462c430627b29d00ce9c718874
-  data.tar.gz: 60c51e32d1ddd33291fe0cbc930b09dd18c6f706
+  metadata.gz: d650f6e958d2689681efefb8e199dce96853ac12
+  data.tar.gz: e7ba48721c169bae0ee59e269b0863972d22bfdb
 SHA512:
-  metadata.gz: a9f561e9efc1c6180264896d66d1bab28d8c8a5ac5b5b16c1f8ed1dd08c668e19f1b596e418ed7a0b288ebda99dfac566ff75066b834b7d50acaec78147f6b41
-  data.tar.gz: e81b583feb2a1bdadf8c433d38193c9f5965078a080c34e0a4c919c16e51e9e60e0bb12d016f200dc329d4aacd193840c9627e255c8d0518e4feeb83b1fc7683
+  metadata.gz: c338e64470b4093743bc8f7b92e47698aa315560ac7904dd30014f8cd23dc6c6d970853a4c32b28788148d2e43850d7cabfd561bf03f335b78e11e09ed2b42c9
+  data.tar.gz: a0d1574e6738232cbb320db2e73fa63dc7941751caa276e8e080e925dd04f716a5af196bd9c121cb64e41d818053e0a2e4c432a0c4d6057ddd5d4a8f195e9cc2

data/README.md

@@ -1,6 +1,6 @@
 This is an ORM similar to ActiveRecord, but uses the filesystem instead.
 
-It uses TMSU which is a "non-hierarchical" filesystem tagging system.
+It uses TMSU which is a filesystem tagging system.
 
 Usage:
 
@@ -17,7 +17,8 @@ require 'tmsu_file_db'
 
 class User < TmsuModel
 
-  # this configure block is optional, it defaults to the current directory
+  # this configure block is optional
+  # it defaults to a randomly named dir in ./db
   configure root_path: "./db/users"
 
   # Validations must return an array
@@ -35,22 +36,23 @@ end
 
 **Create instances**
 
+```rb
 # create, update, and delete
 u = User.new name: "max"
 u.valid? # => false
 u.errors # => ["email isn't valid"]
 u.save # => false
-u.email = "maxpleaner@gmail.com"
+u.[:email] = "maxpleaner@gmail.com"
 u.valid? # => true
 u.save # => true
 u.update(email: "max.pleaner@gmail.com") # => true
 u.update(email: "") # => false
 
-# There are getter/setter methods for convenience
+# There are getter methods for convenience
+# Setters need to use []=
 u.name # => "max"
 u["name"] # => "max"
 u[:name] # => "max"
-u.name = "max p."
 u[:name] # => "max p."
 
 # All these getter/setters are working on 'attributes' under the hood.
@@ -66,12 +68,18 @@ u.write "hello"
 # The content of the file is not part of the "attributes" i.e. name and email
 # Those are stored using TMSU tags
 u.tags # => { email: "max.pleaner@gmail.com", name: "max" }
+u.tags == u.attributes # true
 
 # Attributes can be deleted
 u.delete :name
 u.tags # => { email: "max.pleaner@gmail.com" }
+
+# Records can be deleted (this will destroy the file)
+u.destroy
+
 ```
 
+
 **Use class-level query methods**
 
 _Note that this does not use Arel or any of that jazz. So chaining queries or using joins will not work._
@@ -82,16 +90,24 @@ _Note also that there is no `id` on models, only `path`, which is an absolute pa
 User.where(name: "max p.")[0].name == "max p." # => true
 User.find_by(name: "max p.").name == "max p." # => true
 User.update_all(name: "max") # => true
-User.all[0].name == "max" # => true
 
 # You can make arbitrary queries using TMSU syntax
 # e.g. select all users with email set that are not named melvin
 User.query("name != 'melvin' and email")[0].name == "max" # => true
 ```
 
-You can also skip `TmsuModel` and use `TmsuRuby.file` instead. This does _not_ handle creation / deletion of files. It should only be used with files that already exist.
+Although there's an index method (`all`), there's no typical auto-incrementing ids stored in TMSU. So to load a single, arbitrary record without tags, its file path is used:
 
-Note that these methods are technically available on `TmsuModel` instances, callable on the `tmsu_file` attribute. But this shoudln't be done, because it will cause the in-memory attributes to be out of sync.
+```rb
+  u.path # => "./db/users/23uj8d9j328dj"
+  User.from_file(u.path).name == "max p."
+```
+
+**Use TmsuRuby.file**
+
+An alternative to `TmsuModel` is to use `TmsuRuby.file` instead. This does _not_ handle creation / deletion of files. It should only be used with files that already exist.
+
+Note that these methods are technically available on `TmsuModel` instances as well. But this shouldn't be done, because it will cause the in-memory attributes to be out of sync. Also, some operations like `tag` will error if called on unsaved records.
 
 ```rb
 file_path = './my_pic.jpg' # this should already exist
@@ -132,11 +148,18 @@ TmsuRuby.file("./my_pic.jpg").tags
 # => { foo: nil, a: nil, b: nil, d: 2 }
 ```
 
-Using `TmsuRuby.file` you can search by tag as well:
+Using `TmsuRuby.file` you can search by tag as well. All these methods return
+an array of absolute paths
 
 ```rb
-# Returns array of paths (files with the tag, systemwide)
-TmsuRuby.file("name")
+query_glob = "./**/*.jpg"
+
+# To perform a scoped search (the same used by .where, .find_by, and .query):
+# This is a simple query, but the whole TMSU syntax is available
+TmsuRuby.file(query_glob).paths_query("foo")
+
+# Search the whole filesystem for files with tag
+TmsuRuby.file.files("foo")
 ```
 
 

data/lib/tmsu_file_db.rb

@@ -12,18 +12,31 @@ class TmsuModel
   Validations = Hash.new { |h,k| h[k] = [] }
   Callbacks = {}
 
+
   def self.query_glob
-    "#{Config[:root_path] || "."}/*"
+    "#{root_path}/*"
+  end
+
+  def self.root_path
+    Config[:root_path] || generate_path(within: "./db")
+  end
+
+  def self.generate_path(within: '.')
+    loop do
+      path = "#{within}/#{SecureRandom.hex}"
+      break path unless File.exists?(path)
+    end
   end
 
   def self.configure(root_path:)
     Config[:root_path] = root_path || "./db".tap do |path|
-      `mkdir -p #{path}`
+    `mkdir -p #{path}`
     end
   end
 
-  def self.validate(attribute=nil, &blk)
-    if attribute
+
+  def self.validate(attribute=:generic, &blk)
+    if attribute == :generic
       Validations[:generic] << blk
     else
       Validations[attribute] << blk
@@ -37,12 +50,18 @@ class TmsuModel
   def self.opts_to_query opts
     case opts
     when Array
-      opts.join " "
+      opts.map { |opt| escape_whitespace opt }.join " "
     when Hash
-      opts.map { |k,v| "#{k}={v}" }.join(" ")
+      opts.map do |k,v|
+        "#{escape_whitespace k}=#{escape_whitespace v}"
+      end.join(" ")
     end
   end
 
+  def self.create(attrs)
+    new(attrs).tap(&:save)
+  end
+
   def self.find_by opts
     where(opts).first
   end
@@ -51,19 +70,32 @@ class TmsuModel
     query opts_to_query opts
   end
 
-  def self.all
+  def self.escape_whitespace(string)
+    string.to_s.gsub(/(?<!\\)\s/, '\ ')
+  end
+
+  def self.escape_hash_whitespace(hash)
+    hash.reduce({}) do |result, (k,v)|
+      result[escape_whitespace(k)] = escape_whitespace v
+      result
+    end
+  end
+
+  def self.from_file(path)
+    new(escape_hash_whitespace TmsuRuby.file(path).tags) { path }
+  end
 
+  def self.all
+    Dir.glob(query_glob).map &method(:from_file)
   end
 
   def self.query string
-    TmsuFile.new(query_glob).paths_query(query).map do |path|
-      new TmsuFile.new(path).tags
-    end
+    TmsuRuby.file(query_glob).paths_query(string).map &method(:from_file)
   end
 
   def self.update_all opts={}
     Dir.glob(query_glob).each do |path|
-      errors = new(path).tap { |inst| inst.update(opts) }.errors
+      errors = from_file(path).tap { |inst| inst.update(opts) }.errors
       unless errors.empty?
         raise(
           ArgumentError, "couldn't update all. Path #{path} caused errors: #{errors.join(", ")}"
@@ -74,30 +106,36 @@ class TmsuModel
   end
 
   def self.destroy_all opts={}
-    Dir.glob(query_glob).each { |path| `rm #{path}` }
-    true
+    Dir.glob(query_glob).tap { |list| list.each { |path| `rm #{path}` } }
   end
 
   attr_reader :attributes, :errors, :path
 
-  def initialize(attrs={})
+  def initialize(attrs={}, &blk)
     attrs = attrs.with_indifferent_access
-    @path = build_id(attrs.delete :id)
+    # normally for re-initializing a record from a file, .from_file is used.
+    # but there is another way, which is to pass a block to initialize
+    # which returns a path string.
+    # Example: TmsuModel.new { "file.txt" }.path # => "file.txt"
+    @path = blk ? blk.call : build_path
     @attributes = attrs
     @persisted = File.exists? @path
     @errors = []
   end
 
-  def build_id(given=nil)
-    rand_id = given || SecureRandom.urlsafe_base64
-    prefix = "#{self.class::Config[:root_path]}"
-    if prefix
-      "#{prefix}/#{rand_id}"
-    else
-      "#{rand_id}"
+  def ensure_root_path
+    unless @root_dir_created
+      `mkdir -p #{self.class.root_path}`
+      @root_dir_created = true
     end
   end
 
+  def build_path
+    self.class.generate_path(
+      within: self.class::Config[:root_path] || "."
+    )
+  end
+
   def []=(k,v)
     attributes[k] = v
   end
@@ -106,11 +144,12 @@ class TmsuModel
     attributes[k]
   end
 
+  # Forwards method missing to getter, if possible
+  # To respect indifferent access of attributes,
+  # uses has_key? instead of keys.include?
   def method_missing(sym, *arguments, &blk)
-    attr_name = sym.to_s[0..-1]
-    if sym.to_s[-1] == "=" && attributes.keys.include?(attr_name)
-      attributes[attr_name] = arguments[0]
-    elsif attributes.keys.include? sym
+    super unless defined?(attributes) && attributes.is_a?(Hash)
+    if attributes.has_key? sym
       attributes[sym]
     else
       super
@@ -156,8 +195,17 @@ class TmsuModel
 
   def save
     ensure_persisted
+    ensure_root_path
+    original_attributes = tags
+    attributes.each do |k,v|
+      if !v.nil? && !(original_attributes[k] == v)
+        untag "#{k}=#{original_attributes[k]}"
+      end
+    end
     return false unless valid?
     tag attributes
+    @persisted = true
+    @attributes = tags.with_indifferent_access
     true
   end
 
@@ -175,22 +223,33 @@ class TmsuModel
   end
 
   def destroy
+    `tmsu-fs-rm #{path}`
     `rm #{path}`
+    @persisted = false
     self
   end
 
   def delete(attr)
-    untag(attr)
+    if attributes[attr].nil?
+      untag(attr)
+    else
+      val = attributes[attr]
+      untag("#{attr}=#{val}")
+    end
     attributes.delete attr
-    attr
   end
 
 end
 
+# This patch doesn't do anything unless ENV["DEBUG"] is set
 module SystemPatch
   refine Object do
     def system string
-      `#{string}`.tap &method(:puts)
+      if ENV["DEBUG"]
+        return `#{string}`.tap &method(:puts)
+      else
+        return `#{string}`
+      end
     end
   end
 end
@@ -202,11 +261,11 @@ module TmsuRubyInitializer
   end
   def init_tmsu
     puts "initializing tmsu"
-    puts system "tmsu init"
+    system "tmsu init"
     puts "making vfs_path #{vfs_path}"
-    puts system "mkdir -p #{vfs_path}"
+    system "mkdir -p #{vfs_path}"
     puts "mounting vfs path"
-    puts system "tmsu mount #{vfs_path}"
+    system "tmsu mount #{vfs_path}"
   end
   def vfs_path
     "/home/max/tmsu_vfs"
@@ -217,42 +276,60 @@ module TmsuFileAPI
 
   using SystemPatch
 
+  def persisted?
+    return super if defined?(super)
+    File.exists? path
+  end
+
   def tags
-    system("tmsu tags #{path}").split(" ")[1..-1].reduce({}) do |res, tag|
-      key, val = tag.split("=")
+    return {} unless persisted?
+    delimiter = /(?<!\\)\s/
+    cmd_res = system("tmsu tags #{path}")
+    cmd_res.chomp.split(delimiter)[1..-1].reduce({}) do |res, tag|
+      key, val = tag.split("=").map do |str|
+        str
+      end
       res.tap { res[key] = val }
     end
   end
 
+  def require_persisted
+    unless persisted?
+      raise(RuntimeError, "called tags on unsaved record. path: #{path}")
+    end
+  end
+
   def paths_query(query)
-    query_root = "#{vfs_path}/queries/#{query}"
+    query_root = %{#{vfs_path}/queries/"#{query}"}
     system("ls #{query_root}").split("\n").map do |filename|
       system("readlink #{query_root}/#{filename}").chomp
     end
   end
 
   def untag tag_list
-    `touch #{path}` unless persisted?
+    `touch #{path}`
     system "tmsu untag #{path} #{tag_list}"
     tags
   end
 
   def tag tag_obj
-    `touch #{path}` unless persisted?
-    system "tmsu tag #{path} #{build_tag_arg tag_obj}"
+    `touch #{path}`
+    system %{tmsu tag #{path} #{build_tag_arg tag_obj}}
     tags
   end
 
   def build_tag_arg obj
     case obj
     when String
-      obj
+      %{"#{obj}"}
     when Array
-      obj.join " "
+      obj.map { |x| %{"#{x}"} }.join " "
     when Hash
-      obj.map {|k,v| "#{k}=#{v}" }.join " "
+      obj.map do |k,v|
+        %{"#{k}=#{v}"}
+      end.join " "
     else
-      obj
+      %{"#{obj}"}
     end
   end
 
@@ -268,7 +345,7 @@ module TmsuFileAPI
     when Array
       tag_obj.join(" ")
     end
-    system "tmsu tag --tags '#{build_tag_arg tag_obj}' #{path}"
+    system "tmsu untag --tags '#{build_tag_arg tag_obj}' #{path}"
     files tag_obj
   end
 
@@ -294,10 +371,6 @@ class TmsuRuby
     TmsuRuby::TmsuFile.new path, vfs_path
   end
 
-  def self.model(path=nil)
-    record = TmsuModel.new id: path
-  end
-
   class TmsuFile
     include TmsuFileAPI
     attr_reader :path, :vfs_path

data/lib/version.rb

@@ -1,3 +1,3 @@
 module TmsuFileDb
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tmsu_file_db
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - maxpleaner