treet 0.8.2 → 0.10.2

data/.gitignore

@@ -15,4 +15,3 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-*.json

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - rbx-19mode

data/Gemfile

@@ -2,5 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in treet.gemspec
 gemspec
-
-gem 'thor'

data/Guardfile

@@ -1,9 +1,28 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
+guard 'minitest', test_folders: 'spec', test_file_patterns: 'test_*.rb' do
+  # with Minitest::Unit
+  # watch(%r{^spec/lib/test_.*\.rb})
+
+  # watch(%r|^test/(.*)\/?test_(.*)\.rb|)
+  # watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+
+  # watch(%r|^lib/otherbase/contacts?.rb|)  { "test" }
+
+  # with Minitest::Spec
+  watch(%r|^spec/lib/test_(.*)\.rb|)
+  watch(%r{^lib/treet/(.+)\.rb$})     { |m| "spec/lib/test_#{m[1]}.rb" }
+  watch(%r|^spec/test_helper\.rb|)    { "spec" }
+  # watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  # watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end
+
 guard 'rspec', :version => 2 do
   watch(%r{^spec/.+_spec\.rb$})
+
   watch(%r{^lib/treet/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   watch(%r{^(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 end
+

data/lib/treet/farm.rb

@@ -1,23 +1,24 @@
 # encoding: UTF-8
 
-require "uuidtools"
+require "securerandom"
 
 class Treet::Farm
-  attr_reader :root, :xrefkey
+  attr_reader :root, :xrefkey, :repotype
 
   def initialize(opts)
     raise Errno::ENOENT unless File.directory?(opts[:root])
 
     @root = opts[:root]
     @xrefkey = opts[:xref]
+    @repotype = opts[:repotype] || Treet::Repo
   end
 
-  def repos
+  def repos(opts = {})
     @repos_cache ||= Dir.glob("#{root}/*").each_with_object({}) do |subdir,h|
       # in a Farm we are looking for repositories under the root
       if File.directory?(subdir)
         xref = File.basename(subdir)
-        h[xref] = Treet::Repo.new(subdir, :xrefkey => xrefkey, :xref => xref)
+        h[xref] = repotype.new(subdir, opts.merge(:xrefkey => xrefkey, :xref => xref))
       end
     end
   end
@@ -41,13 +42,13 @@ class Treet::Farm
     array_of_hashes = JSON.load(File.open(jsonfile))
     Dir.chdir(rootdir) do
       array_of_hashes.each do |h|
-        uuid = UUIDTools::UUID.random_create.to_s
+        uuid = SecureRandom.uuid
         thash = Treet::Hash.new(h)
-        thash.to_repo(uuid)
+        thash.to_repo(uuid, opts)
       end
     end
 
-    Treet::Farm.new(:root => rootdir, :xref => opts[:xref])
+    self.new(opts)
   end
 
   # apply patches to a farm of repos
@@ -62,9 +63,11 @@ class Treet::Farm
   end
 
   # add a new repo, with data from an input hash
-  def add(hash)
-    uuid = UUIDTools::UUID.random_create.to_s
+  # if an :id is provided, then the new repo will be stored under that directory name,
+  # otherwise a unique id will be generated
+  def add(hash, opts = {})
+    uuid = opts[:id] || UUIDTools::UUID.random_create.to_s
     thash = Treet::Hash.new(hash)
-    thash.to_repo("#{root}/#{uuid}")
+    repos[uuid] = thash.to_repo("#{root}/#{uuid}", opts.merge(:repotype => repotype))
   end
 end

data/lib/treet/gitfarm.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+class Treet::Gitfarm < Treet::Farm
+  attr_reader :author
+
+  def initialize(opts)
+    raise ArgumentError, "No git farm without an author for commits" unless opts[:author]
+    super
+    @repotype = Treet::Gitrepo
+    @author = opts[:author]
+  end
+
+  def self.plant(opts)
+    super(opts.merge(:repotype => Treet::Gitrepo))
+  end
+
+  def repos
+    super(:author => author)
+  end
+
+  def add(hash, opts = {})
+    repo = super(hash, opts.merge(:author => author))
+    if opts[:tag]
+      repo.tag(opts[:tag])
+    end
+    repo
+  end
+end

data/lib/treet/gitrepo.rb

@@ -0,0 +1,180 @@
+# encoding: UTF-8
+
+require "rugged"
+require "forwardable"
+
+class Treet::Gitrepo < Treet::Repo
+  extend Forwardable
+  def_delegators :@gitrepo, :head, :refs, :index
+
+  def initialize(path, opts = {})
+    raise ArgumentError, "author required for updates" unless opts[:author]
+    super
+
+    @author = opts[:author]
+
+    begin
+      @gitrepo = Rugged::Repository.new(root)
+    rescue Rugged::RepositoryError
+      @gitrepo = initialize_gitrepo
+      add_and_commit!
+    end
+  end
+
+  def tags
+    gitrepo.refs(/tags/)
+  end
+
+  def tag(tagname)
+    refname = "refs/tags/#{tagname}"
+    begin
+      if tag_ref = Rugged::Reference.lookup(gitrepo, refname)
+        # move an existing tag
+        tag_ref.target = head.target
+      else
+        # new tag
+        Rugged::Reference.create(gitrepo, refname, head.target)
+      end
+    rescue Rugged::ReferenceError
+      # invalid string for source, e.g. blank or illegal punctuation (colons)
+      raise ArgumentError "invalid source string '#{tagname}' for repository tagging"
+    end
+  end
+
+  def patch(patchdef)
+    super
+    add_and_commit!
+  end
+
+  def to_hash(opts = {})
+    if opts[:commit]
+      snapshot(opts[:commit])
+    elsif opts[:tag]
+      tag_snapshot(opts[:tag])
+    else
+      # snapshot(head.target)
+      super()
+    end
+  end
+
+  def entries
+    index.entries.map{|e| e[:path]}
+  end
+
+  def branches
+    refs(/heads/).map(&:name) - ['refs/heads/master']
+  end
+
+  # always branch from tip of master (private representation)
+  def branch(name)
+    Rugged::Reference.create(gitrepo, "refs/heads/#{name}", head.target)
+  end
+
+  def version(opts = {})
+    if tag = opts[:tag]
+      ref = Rugged::Reference.lookup(gitrepo, "refs/tags/#{tag}")
+      ref && ref.target
+    else
+      head.target
+    end
+  end
+
+  private
+
+  attr_reader :gitrepo, :author
+
+  def initialize_gitrepo
+    Rugged::Repository.init_at(root, false)
+  end
+
+  # always commits to HEAD
+  def commit!(sha)
+    parent_shas = begin
+      [gitrepo.head.target]
+    rescue Rugged::ReferenceError
+      # this is the first commit
+      []
+    end
+
+    authorship = author.merge(:time => Time.now)
+
+    sha = Rugged::Commit.create(gitrepo,
+      :message => "",
+      :author => authorship,
+      :committer => authorship,
+      :parents => parent_shas,
+      :tree => sha,
+      :update_ref => "HEAD"
+    )
+
+    sha
+  end
+
+  def add_and_commit!
+    current_index = entries
+    Dir.chdir(root) do
+      current_files = Dir.glob('**/*')
+
+      # additions
+      (current_files - current_index).each do |file|
+        # must add each filename explicitly, `index#add` does not recurse into directories
+        if File.file?(file)
+          index.add(file)
+        end
+      end
+
+      # possible alterations - these changes won't be detected unless we explicitly git-add
+      (current_files & current_index).each do |file|
+        if File.file?(file)
+          index.add(file)
+        end
+      end
+
+      # deletions
+      (current_index - current_files).each do |file|
+        # `index#remove` handles directories
+        index.remove(file)
+      end
+    end
+
+    index.write
+    tree_sha = index.write_tree
+    commit!(tree_sha)
+  end
+
+  def snapshot(commit_sha)
+    commit = gitrepo.lookup(commit_sha)
+    tree = commit.tree
+    # must traverse the tree: entries are files or subtrees
+    data = {}
+    tree.each do |obj|
+      data[obj[:name]] = case obj[:type]
+      when :blob
+        begin
+          JSON.load(gitrepo.read(obj[:oid]).data)
+        rescue JSON::ParserError
+          raise JSON::ParserError, "bad JSON in blob #{obj[:name]}: #{gitrepo.read(obj[:oid]).data}"
+        end
+      when :tree
+        begin
+          gitrepo.lookup(obj[:oid]).each_with_object([]) do |subobj,d|
+            d << JSON.load(gitrepo.read(subobj[:oid]).data)
+          end
+        rescue JSON::ParserError
+          raise JSON::ParserError, "bad JSON in tree #{obj[:name]}: #{gitrepo.read(obj[:oid]).data}"
+        end
+      else
+        raise TypeError, "UNRECOGNIZED GIT OBJECT TYPE #{obj[:type]}"
+      end
+    end
+
+    # decorate(data)
+    data
+  end
+
+  def tag_snapshot(tagname)
+    tag_ref = Rugged::Reference.lookup(gitrepo, "refs/tags/#{tagname}")
+    raise ArgumentError, "tag '#{tagname}' does not exist in this repo" unless tag_ref
+    snapshot(tag_ref.target)
+  end
+end

data/lib/treet/hash.rb

@@ -22,9 +22,10 @@ class Treet::Hash
     @data = normalize(d)
   end
 
-  def to_repo(root)
+  def to_repo(root, opts = {})
     construct(data, root)
-    Treet::Repo.new(root)
+    repotype = opts[:repotype] || Treet::Repo
+    repotype.new(root, opts)
   end
 
   def to_hash
@@ -42,8 +43,13 @@ class Treet::Hash
     Treet::Hash.new(newhash)
   end
 
-  def self.digestify(hash)
-    Digest::SHA1.hexdigest(hash.to_a.sort.flatten.join)
+  def self.digestify(data)
+    case data
+    when Hash
+      Digest::SHA1.hexdigest(data.to_a.sort.flatten.join)
+    else # String
+      data
+    end
   end
 
   private
@@ -66,7 +72,7 @@ class Treet::Hash
             case v2
             when String
               # create empty file with this name
-              File.open("#{k}/#{v2}", "w")
+              FileUtils.touch("#{k}/#{v2}")
 
             else
               # store object contents as JSON into a generated filename

data/lib/treet/repo.rb

@@ -1,25 +1,24 @@
 # encoding: UTF-8
 
-# require 'hashdiff'
-
 class Treet::Repo
-  attr_reader :root, :hash, :opts
+  attr_reader :root
 
   def initialize(path, opts = {})
-    # TODO: validate that path exists and is a directory (symlinks should work)
+    raise "Missing or invalid source path #{path}" unless File.directory?(path)
 
     @root = path
-    raise "Missing or invalid source path #{path}" unless File.directory?(path)
-    @opts = opts
   end
 
   def to_hash
-    @hash ||= expand(root)
+    expand(root)
+  end
+
+  def reset
+    # clear any cached data
   end
 
   def compare(target)
     Treet::Hash.diff(to_hash, target.to_hash)
-    # HashDiff.diff(to_hash, hash)
   end
 
   # patch keys can look like
@@ -28,14 +27,14 @@ class Treet::Repo
   # (address[1] syntax has been eliminated, we recognize array elements by matching the entire content)
   def self.filefor(keyname)
     if keyname =~ /\[/
-      keyname, is_array, index = keyname.match(/^(.*)(\[\])$/).captures
+      keyname = keyname.match(/^(.*)\[\]$/).captures.first
       [keyname, '', nil]
     elsif keyname =~ /\./
       # subelement
       filename,field = keyname.split('.')
       ['.', filename, field]
     else
-      [nil, keyname]
+      ['.', keyname]
     end
   end
 
@@ -47,24 +46,31 @@ class Treet::Repo
     Dir.chdir(root) do
       diffs.each do |diff|
         flag, key, v1, v2 = diff
-        if key =~ /\[/
-          keyname, is_array = key.match(/^(.*)(\[\])$/).captures
-        elsif key =~ /\./
-          keyname, subkey = key.match(/^(.*)\.(.*)$/).captures
-        else
-          keyname = key
-        end
+        # if key =~ /\[/
+        #   keyname = key.match(/^(.*)\[\]$/).captures
+        # elsif key =~ /\./
+        #   keyname, subkey = key.match(/^(.*)\.(.*)$/).captures
+        # else
+        #   keyname = key
+        # end
 
         dirname, filename, fieldname = Treet::Repo.filefor(key)
         filepath = "#{dirname}/#{filename}"
+
         case flag
         when '~'
           # change a value in place
           # load the current data & overwrite with the new value
           # idempotent: this will overwrite the file with the same contents
-          data = File.exists?(filepath) ? JSON.load(File.open(filepath)) : {}
-          data[fieldname] = v1
-          File.open(filepath, "w") {|f| f << JSON.pretty_generate(data)}
+          if fieldname
+            # hash entry
+            data = File.exists?(filepath) ? JSON.load(File.open(filepath)) : {}
+            data[fieldname] = v1
+            File.open(filepath, "w") {|f| f << JSON.pretty_generate(data)}
+          else
+            # string entry
+            File.open(filepath, "w") {|f| f << v1}
+          end
 
         when '+'
           # add something
@@ -80,19 +86,31 @@ class Treet::Repo
             # idempotent: this will overwrite the file with the same contents
             subfile = "#{dirname}/#{Treet::Hash.digestify(v1)}"
             Dir.mkdir(dirname) unless Dir.exists?(dirname)
-            File.open(subfile, "w") {|f| f << JSON.pretty_generate(v1)}
+            case v1
+            when Hash
+              # hash entry
+              File.open(subfile, "w") {|f| f << JSON.pretty_generate(v1)}
+            else
+              # string entry - create empty file with this name
+              FileUtils.touch(subfile)
+            end
           end
 
         when '-'
           # remove something
           if fieldname
+            # this is a key in a subhash
             data = JSON.load(File.open(filepath))
             data.delete(fieldname)
             if data.empty?
+              # all keys have been removed, clean up the file
               File.delete(filename)
             else
               File.open(filepath, "w") {|f| f << JSON.pretty_generate(data)}
             end
+          elsif dirname == "."
+            # this is a top-level string
+            File.delete(filename) if File.exists?(filename) # need the existence check for idempotence
           else
             # this is an array, we look for a match on the entire contents via digest
             subfile = "#{dirname}/#{Treet::Hash.digestify(v1)}"
@@ -130,12 +148,6 @@ class Treet::Repo
 
   def expand(path)
     files = Dir.entries(path).select {|f|  f !~ /^\./}
-    hash = files.each_with_object({}) {|f,h| h[f] = expand_json("#{path}/#{f}")}
-
-    if opts[:xrefkey]
-      hash['xref'] ||= {}
-      hash['xref'][opts[:xrefkey]] = opts[:xref]
-    end
-    hash
+    files.each_with_object({}) {|f,h| h[f] = expand_json("#{path}/#{f}")}
   end
 end

data/lib/treet/version.rb

@@ -1,3 +1,3 @@
 module Treet
-  VERSION = "0.8.2"
+  VERSION = "0.10.2"
 end

data/lib/treet.rb

@@ -6,8 +6,13 @@ unless Kernel.respond_to?(:require_relative)
   end
 end
 
-require_relative "treet/version"
+%w(version hash repo farm).each do |f|
+  require_relative "treet/#{f}"
+end
 
-require_relative "treet/repo"
-require_relative "treet/hash"
-require_relative "treet/farm"
+# under MacRuby 0.12, the `rugged` gem causes seg fault, sometimes merely on require()
+unless defined? MACRUBY_VERSION
+  %w(gitrepo gitfarm).each do |f|
+    require_relative "treet/#{f}"
+  end
+end

data/spec/json/four.json

@@ -0,0 +1,8 @@
+{
+  "title": "This is the title",
+  "datalist": [
+    "one",
+    "two",
+    "three"
+  ]
+}

data/spec/lib/repo_spec.rb

@@ -9,6 +9,17 @@ describe "Repo" do
     }
   end
 
+  it "should reload on reset" do
+    repo = Treet::Repo.new("#{File.dirname(__FILE__)}/../repos/one")
+    repo.to_hash.should == {
+      'name' => {'full' => 'John Bigbooté'}
+    }
+    repo.reset
+    repo.to_hash.should == {
+      'name' => {'full' => 'John Bigbooté'}
+    }
+  end
+
   it "should generate optional " do
     repo = Treet::Repo.new("#{File.dirname(__FILE__)}/../repos/one")
     repo.to_hash.should == {
@@ -41,15 +52,16 @@ describe "Repo" do
   it "should generate file paths correctly from key paths in patches" do
     Treet::Repo.filefor("name.first").should == [".", "name", "first"]
     Treet::Repo.filefor("emails[]").should == ['emails', "", nil]
+    Treet::Repo.filefor("topvalue").should == ['.', "topvalue"]
   end
 
-  it "should added xref keys when specified" do
-    repo = Treet::Repo.new("#{File.dirname(__FILE__)}/../repos/one", :xrefkey => 'foo', :xref => 'bar')
-    repo.to_hash.should == {
-      'name' => {'full' => 'John Bigbooté'},
-      'xref' => {'foo' => 'bar'}
-    }
-  end
+  # it "should add xref keys when specified" do
+  #   repo = Treet::Repo.new("#{File.dirname(__FILE__)}/../repos/one", :xrefkey => 'foo', :xref => 'bar')
+  #   repo.to_hash.should == {
+  #     'name' => {'full' => 'John Bigbooté'},
+  #     'xref' => {'foo' => 'bar'}
+  #   }
+  # end
 
   it "should take patches that add values to missing elements" do
     hash = Treet::Hash.new("#{File.dirname(__FILE__)}/../json/one.json")
@@ -88,4 +100,100 @@ describe "Repo" do
       newhash['foo']['bar'].should == 'new value'
     end
   end
+
+  it "should accept patches that update top-level values" do
+    hash = Treet::Hash.new("#{File.dirname(__FILE__)}/../json/four.json")
+    Dir.mktmpdir do |dir|
+      repo = hash.to_repo(dir)
+      repo.patch([
+        [
+          "~",
+          "title",
+          "Updated Title"
+        ]
+      ])
+      newhash = repo.to_hash
+      newhash['title'].should == 'Updated Title'
+
+      repo.patch([
+        [
+          "-",
+          "datalist[]",
+          "two"
+        ]
+      ])
+      newhash = repo.to_hash
+      newhash['datalist'].count.should == 2
+    end
+  end
+
+  it "should add hash entries inside existing arrays" do
+    hash = Treet::Hash.new(load_json('two'))
+    Dir.mktmpdir do |dir|
+      repo = hash.to_repo(dir)
+      repo.patch([
+        [
+          "+",
+          "emails[]",
+          {"label" => "home", "label" => "myname@gmail.com"}
+        ]
+      ])
+      newhash = repo.to_hash
+      newhash['emails'].count.should == 3
+      newhash['emails'].each {|x| x.is_a?(Hash).should be_true}
+    end
+  end
+
+  it "should clean up after a subhash deletion patch" do
+    hash = Treet::Hash.new("#{File.dirname(__FILE__)}/../json/one.json")
+    Dir.mktmpdir do |dir|
+      repo = hash.to_repo(dir)
+      repo.patch([
+        [
+          "-",
+          "name.full",
+          "oldval"
+        ]
+      ])
+      newhash = repo.to_hash
+      newhash.keys.should be_empty
+    end
+  end
+
+  it "should clean up after a top-level string deletion patch" do
+    hash = Treet::Hash.new("#{File.dirname(__FILE__)}/../json/four.json")
+    Dir.mktmpdir do |dir|
+      repo = hash.to_repo(dir)
+      repo.patch([
+        [
+          "-",
+          "title",
+          "oldval"
+        ]
+      ])
+      newhash = repo.to_hash
+      newhash.keys.should == ['datalist']
+    end
+  end
+
+  it "should create empty files correctly when patch adds elements" do
+    hash = Treet::Hash.new("#{File.dirname(__FILE__)}/../json/four.json")
+    Dir.mktmpdir do |dir|
+      repo = hash.to_repo(dir)
+      repo.patch([
+        [
+          "+",
+          "datalist[]",
+          "two"
+        ],
+        [
+          "+",
+          "datalist[]",
+          "seven"
+        ]
+      ])
+      newhash = repo.to_hash
+      newhash.to_hash['datalist'].should be_include('seven')
+    end
+  end
 end