git-ds 0.9.2

data/doc/examples/user_group/ug_init.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# Initialize a user/group database repo
+# Copyright 2011 Thoughtgang <http://www.thoughtgang.org>
+
+BASE=File.dirname(File.expand_path(__FILE__)\
+                 ).split(File::SEPARATOR)[0..-4].join(File::SEPARATOR)
+$: << BASE + File::SEPARATOR + 'lib'
+$: << BASE + File::SEPARATOR + 'doc' + File::SEPARATOR + 'examples'
+
+require 'user_group/model'
+
+if __FILE__ == $0
+  if ARGV.count != 1 
+    puts "Usage : #{$0} FILENAME"
+    exit -1
+  end 
+
+  UserGroupModel.new(GitDS::Database.connect(ARGV.shift, true))
+  exit 0
+end

data/doc/examples/user_group/ug_list.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# List User/Group database contents
+# Copyright 2011 Thoughtgang <http://www.thoughtgang.org>
+
+BASE=File.dirname(File.expand_path(__FILE__)\
+                 ).split(File::SEPARATOR)[0..-4].join(File::SEPARATOR)
+$: << BASE + File::SEPARATOR + 'lib'
+$: << BASE + File::SEPARATOR + 'doc' + File::SEPARATOR + 'examples'
+
+require 'user_group/model'
+
+if __FILE__ == $0
+
+  path = ARGV.count == 1 ? ARGV.shift : GitDS::Database.top_level
+  model = UserGroupModel.new(GitDS::Database.connect(path, false))
+  raise "Could not connect to model" if not model
+
+  puts "Users:"
+  model.users.each do |user|
+    u = model.user(user)
+    puts "\t#{u.id}\t#{u.username}\t#{u.created}\t#{u.full_name}"
+  end
+
+  puts "\nGroups:"
+  model.groups.each do |grp|
+    puts "\t#{grp}"
+    g = model.group(grp)
+    puts "\t#{g.id}\t#{g.name}\t#{g.owner.username}\t#{g.users.inspect}"
+  end
+
+  exit 0
+end

data/lib/git-ds.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# :title: GitDS
+=begin rdoc
+<i>Copyright 2011 Thoughtgang <http://www.thoughtgang.org></i>
+=end
+
+require 'git-ds/shared'
+require 'git-ds/index'
+require 'git-ds/repo'
+require 'git-ds/config'
+require 'git-ds/database'
+require 'git-ds/exec_cmd'
+require 'git-ds/transaction'
+require 'git-ds/model'

data/lib/git-ds/config.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# :title: Git-DS::RepoConfig
+=begin rdoc
+
+Copyright 2011 Thoughtgang <http://www.thoughtgang.org>
+=end
+
+module GitDS
+
+=begin rdoc
+Provides access to the repo .git/config file as a hash.
+
+Note that this limits access to a specific section of the config file,
+named by the parameter 'section'.
+=end
+  class RepoConfig
+
+    def initialize(db, section='misc')
+      @db = db
+      @section = clean(section)
+    end
+
+=begin rdoc
+Clean key so it is a valid Config token
+=end
+    def clean(str)
+      str.gsub(/[^-[:alnum:]]/, '-')
+    end
+
+=begin rdoc
+Return the full path to the variable for 'key'.
+=end
+    def path(key)
+      @section + '.' + clean(key)
+    end
+
+=begin rdoc
+Return the String value of the variable 'key'.
+=end
+    def [](key)
+      rv = @db.repo_config[path(key)]
+      rv ? rv : ''
+    end
+
+=begin rdoc
+Writes the String representation of 'value' to the variable 'key'.
+=end
+    def []=(key, value)
+      @db.repo_config[path(key)] = value.to_s
+    end
+  end
+
+end

data/lib/git-ds/database.rb

@@ -0,0 +1,289 @@
+#!/usr/bin/env ruby
+# :title: Git-DS::Database
+=begin rdoc
+
+Copyright 2011 Thoughtgang <http://www.thoughtgang.org>
+=end
+
+require 'fileutils'
+
+require 'git-ds/repo'
+require 'git-ds/config'
+require 'git-ds/model'
+require 'git-ds/shared'
+require 'git-ds/exec_cmd'
+require 'git-ds/transaction'
+
+module GitDS
+
+=begin rdoc
+Exception raised when a closed database is accessed
+=end
+  class InvalidDbError < RuntimeError
+  end
+
+=begin rdoc
+Actually DbConnection to the repository.
+
+Note: all operations should be in exec or transaction blocks. These use a
+persistent staging index, and are more efficient.
+=end
+  class Database < Repo
+
+=begin rdoc
+Flag to mark if database has been closed (i.e. connection is invalid).
+=end
+    attr_reader :stale
+
+=begin rdoc
+Actor to use when performing Database operations. All Transaction and
+ExecCmd objects will use this actor by default.
+
+Default is nil (i.e. let Git read actor from .git/config or ENV).
+=end
+    attr_accessor :actor
+
+=begin rdoc
+Return a connection to the Git DB.
+Creates the DB if it does not already exist.
+=end
+    def initialize(path, username=nil, email=nil)
+      init = false
+      if not File.exist? path
+        Repo.create(path)
+        init = true
+      end
+
+      @stale = false
+      super(path)
+
+      if init
+        # initial commit is needed for branches to work smoothly
+        stage { |idx| idx.add('.git-ds/version', "1.0\n") }
+        staging.commit('Database initialized.')
+        unstage
+      end
+
+      @actor = Grit::Actor.new(username, email) if username
+    end
+
+=begin rdoc
+Open a connection to database.
+
+If 'create' is true (the default), a database will be created if one does
+not exist at 'path'.
+=end
+    def self.connect(path, create=true)
+      return nil if (not create) && (not File.exist? path)
+      connect_as(path, nil, nil, create)
+    end
+
+=begin rdoc
+Connect to a git database as the specified user.
+=end
+    def self.connect_as(path, username, email, create=true)
+      return nil if (not create) && (not File.exist? path)
+      new(path, username, email)
+    end
+
+=begin rdoc
+Close DB connection, writing all changes to disk.
+
+NOTE: This does not create a commit! Ony the staging index changes.
+=end
+    def close(save=true)
+      raise InvalidDbError if @stale
+
+      if save && self.staging?
+        self.staging.write
+      end
+      self.staging = nil
+      @stale = true
+
+      # TODO: remove all locks etc
+    end
+
+=begin rdoc
+Delete Database (including entire repository) from disk.
+=end
+    def purge
+      raise InvalidDbError if @stale
+
+      close(false)
+      FileUtils.remove_dir(@path) if ::File.exist?(@path)
+    end
+
+=begin rdoc
+Grit::Repo#config is wrapped by Database#config.
+=end
+    alias :repo_config :config
+
+=begin rdoc
+Provides access to the Hash of Git-DS config variables.
+=end
+    def config
+      @git_config ||= RepoConfig.new(self, 'git-ds')
+    end
+
+=begin rdoc
+Set the Git author information for the database connection. Wrapper for
+actor=.
+=end
+    def set_author(name, email=nil)
+      self.actor = name ? Grit::Actor.new(name, (email ? email : '')) : nil
+    end
+
+=begin rdoc
+Execute a block in the context of the staging index.
+
+See ExecCmd.
+=end
+    def exec(&block)
+      raise InvalidDbError if @stale
+
+      return exec_in_staging(true, &block) if self.staging?
+
+      begin
+        self.staging
+        exec_in_staging(false, &block)
+        self.staging.write
+      ensure
+        self.staging = nil
+      end
+
+    end
+
+=begin
+Execute a transaction in the context of the staging index.
+
+See Transaction.
+=end
+    def transaction(&block)
+      raise InvalidDbError if @stale
+
+      return transaction_in_staging(true, &block) if self.staging?
+
+      begin
+        self.staging
+        transaction_in_staging(false, &block)
+      ensure
+        self.staging = nil
+      end
+    end
+
+=begin rdoc
+Add files to the database. Calls exec to ensure that a write is not performed
+if a staging index already exists.
+=end
+    def add(path, data='', on_fs=false)
+      exec { index.add(path, data, on_fs) }
+    end
+
+=begin rdoc
+Delete an object from the database.
+=end
+    def delete(path)
+      exec { index.delete(path) }
+    end
+
+=begin rdoc
+Wrapper for Grit::Repo#index that checks if Database has been closed.
+=end
+    def index_new
+      raise InvalidDbError if @stale
+      super
+    end
+
+=begin rdoc
+Wrapper for Grit::Repo#staging that checks if Database has been closed.
+=end
+    def staging
+      raise InvalidDbError if @stale
+      super
+    end
+
+=begin rdoc
+Wrapper for Grit::Repo#head that checks if Database has been closed.
+=end
+    def head
+      raise InvalidDbError if @stale
+      super
+    end
+
+=begin rdoc
+Wrapper for Grit::Repo#tree that checks if Database has been closed.
+=end
+    def tree(treeish = 'master', paths = [])
+      raise InvalidDbError if @stale
+      super
+    end
+
+=begin rdoc
+Generate a tag object for the most recent commit.
+=end
+    def mark(msg)
+      tag_object(msg, commits.first.id)
+    end
+
+=begin rdoc
+Branch-and-merge:
+Run block in a transaction under a new branch. If the transaction succeeds,
+the branch is merged back into master.
+
+See Database#transaction .
+=end
+    def branch_and_merge(name=next_branch_tag(), actor=nil, &block)
+      raise InvalidDbError if @stale
+
+
+      # save old actor
+      old_actor = self.actor
+      self.actor = actor if actor
+
+      # save old staging
+      saved_stage = (self.staging?) ? self.staging : nil
+
+      sha = commits.first ? commits.first.id : nil
+      tag = create_branch(name, sha)
+      set_branch(tag, self.actor)
+
+      # ensure staging index is nil [in case branch name was re-used]
+      unstage
+
+      # execute block in a transaction
+      rv = true
+      begin
+        transaction(&block)
+        merge_branch(tag, self.actor)
+      rescue Exception =>e
+        rv = false
+      end
+
+      # restore actor
+      self.actor = old_actor if actor
+
+      rv
+    end
+
+    private
+
+=begin rdoc
+Execute code block in context of current DB index
+=end
+    def exec_in_staging(nested, &block)
+      cmd = ExecCmd.new(self.staging, nested, &block)
+      cmd.actor = self.actor
+      cmd.perform
+    end
+
+=begin rdoc
+Perform transaction in context of current DB index
+=end
+    def transaction_in_staging(nested, &block)
+      t = Transaction.new(self.staging, nested, &block)
+      t.actor = self.actor
+      t.perform
+    end
+
+  end
+end

data/lib/git-ds/exec_cmd.rb

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+# :title: Git-DS::ExecCmd
+=begin rdoc
+
+Copyright 2010 Thoughtgang <http://www.thoughtgang.org>
+=end
+
+require 'git-ds/shared'
+
+module GitDS
+
+=begin rdoc
+A command to be executed in a database context (i.e. an Index).
+
+Usage:
+
+db.exec { |idx| ... }
+
+See also Transaction.
+=end
+  class ExecCmd
+
+=begin rdoc
+The GitDS::Index on which the command operates.
+=end
+    attr_reader :index
+=begin rdoc
+The GitDS::Database on which the command operates. Useful for nesting.
+=end
+    attr_reader :database
+=begin rdoc
+The message to use for the commit at the end of the command.
+=end
+    attr_reader :commit_msg
+    DEFAULT_MESSAGE = 'auto-commit on transaction'
+=begin rdoc
+The Git author for the commit performed at the end of the command.
+See commit_msg.
+=end
+    attr_reader :commit_author
+=begin rdoc
+The body of the command. 
+=end
+    attr_reader :block
+=begin rdoc
+Is command nested (inside a parent)?
+If true, a write and commit will not be performed.
+=end
+    attr_reader :nested
+
+    def initialize(index, nested, msg=DEFAULT_MESSAGE, &block)
+      @index = index
+      @database = index.repo
+      @nested = nested
+      @block = block
+      # Default to no commit
+      @commit_msg = msg
+      # Default to config[user.name] and config[user.email]
+      @commit_author = nil
+    end
+
+=begin rdoc
+Set a commit message for this command.
+=end
+    def message(str)
+      @commit_msg = str
+    end
+
+=begin rdoc
+Set the Git Author info for the commit. By default, this information
+is pulled from the Git config file.
+=end
+    def author(name, email)
+      @commit_author = Grit::Actor.new(name, email)
+    end
+
+=begin rdoc
+Set actor for commit.
+=end
+    def actor=(actor)
+      @commit_author = actor
+    end
+
+=begin rdoc
+Commit index.
+=end
+    def commit
+      self.index.commit(@commit_msg, @commit_author)
+    end
+
+=begin rdoc
+Perform command.
+=end
+    def perform
+      rv = instance_eval(&self.block)
+
+      #self.index.build
+      if not self.nested
+        self.index.build
+        commit
+      end
+
+      rv
+    end
+  end
+
+end