prick 0.2.0

data/lib/prick/ensure.rb

@@ -0,0 +1,119 @@
+module Prick
+  # Example:
+  #
+  #   class Some
+  #     include Ensure
+  #
+  #     def exist?() ... end
+  #     def create() ... end
+  #     def destroy() ... end
+  #
+  #     def loaded?() ... end
+  #     def load() ... end
+  #     def unload() ... end
+  #
+  #     @ensure_states = {
+  #       exist: [:create, :destroy],
+  #       loaded: [:exist, :load, :unload] # Depends on :exist
+  #     }
+  #   end
+  #
+  #   some = Some.new
+  #   some.ensure_state(:loaded) # -> calls #create and then #load
+  #   some.revoke_state(:loaded) # -> calls #unload but not #destroy
+  #   some.ensure_state_value(:exist, false) # same as #revoke_state(:exist)
+  #
+  module Ensure
+    def ensure_state(state, *args) ensure_state_value(state, true, *args) end
+    def revoke_state(state, *args) ensure_state_value(state, false, *args) end
+    def ensure_state_value(state, value, *args) EnsureMethods.ensure(self, state, value, *args) end
+  end
+
+  # Helper module
+  module EnsureMethods
+    def self.klass(module_or_object)
+     module_or_object.is_a?(Module) ? module_or_object : module_or_object.class
+    end
+
+    def self.all_included(m)
+      m.singleton_class.included_modules
+    end
+      
+    def self.all_extended(c)
+      c.ancestors
+    end
+
+    def self.all_states(c)
+      h = {}
+      (all_extended(c) + all_included(c)).reverse.each { |klass|
+        h.merge!(klass.instance_variable_get("@ensure_states") || {})
+      }
+      h
+    end
+
+    def self.ensure(module_or_object, state, expected, *args)
+#     module_or_object_text = module_or_object.is_a?(Module) ? "<module>" : "<object>"
+#     puts "ensure_state_impl(#{module_or_object_text.inspect}, #{state.inspect}, #{expected}, #{args.inspect})"
+
+      object = module_or_object
+      klass = self.klass(module_or_object)
+      value = call_method(object, :"#{state}?", *args)
+
+      if value != expected
+        entry = all_states(klass)[state] or
+            raise Prick::Error, "Can't find state #{state.inspect}"
+
+        # Handle ensure-pre-conditions recursively
+        precondition = (entry.size == 3 ? entry.shift : nil)
+        entry.size == 2 or raise "Malformed state entry for #{state.inspect}"
+        if precondition && expected # Don't tear down recursively
+          case precondition
+            when Symbol
+              self.ensure(object, precondition, true, *args)
+            when Proc
+              call_method(object, precondition, *args)
+          else
+            raise Prick::Fail, "Unexpected value: #{precondition.inspect}"
+          end
+        end
+
+        method = entry[expected ? 0 : 1]
+        case method
+          when true # a noop
+            ;
+          when false # an error
+            relation = (expected ? "to" : "from")
+            raise Error, "Can't change state #{relation} #{state.inspect}"
+          when Symbol # a method
+            call_method(object, method, *args)
+          when Proc # a lambda
+            call_method(object, method, *args)
+        else
+          raise Error, "Illegal @states entry: #{method.inspect}"
+        end
+      end
+      self # so that you can do 'some = Some.new.ensure_state(:loaded)' in one go
+    end
+
+    def self.vargs(arity, args)
+      n_args = (arity < 0 ? -(1 + arity) : arity)
+      args[0...n_args]
+    end
+
+    def self.call_method(object, symbol_or_lambda, *args)
+#     sol_text = symbol_or_lambda.is_a?(Proc) ? "<Proc>" : symbol_or_lambda
+#     puts "call_method(#{object.name}, #{sol_text.inspect}, #{args})"
+
+      if symbol_or_lambda.is_a?(Symbol)
+        executor = object.method(symbol_or_lambda)
+        executor.call(*vargs(executor.arity, args))
+      elsif symbol_or_lambda.is_a?(Proc)
+        executor = symbol_or_lambda
+        executor.call(object, *vargs(executor.arity, args))
+      else
+        raise Prick::Fail, "Illegal value: #{symbol_or_lambda.inspect}"
+      end
+    end
+  end
+end
+

data/lib/prick/exceptions.rb

@@ -0,0 +1,13 @@
+
+module Prick
+  class Error < RuntimeError; end
+  class Fail < Error; end
+  class NotYet < NotImplementedError
+    def initialize() super("Program error - Not yet implemented") end
+  end
+  class AbstractMethod < ScriptError
+    def initialize() super("Program error - Abstract method called") end
+  end
+  class Internal < ScriptError; end
+end
+

data/lib/prick/git.rb

@@ -0,0 +1,159 @@
+
+require "prick/command.rb"
+
+module Prick
+  # Tags have a 'v' prefixed the version in the git repository but this is made
+  # transparent to the application
+  module Git
+    def self.init
+      Command.command "git init"
+    end
+
+    # Returns true if the repository has no modified files. Requires the
+    # repository to have at least one commit. Creating the repository using
+    # Project::initialize_directory guarantees that
+    def self.clean?()
+      Command.command("git status").find { |l| 
+        l =~ /Changes to be committed:/ || l =~ /^\s*modified:/ 
+      }.nil?
+    end
+
+    # Returns true if the repository is on a detached branch
+    def self.detached?
+      line = File.readlines(".git/HEAD").first.chomp
+      line =~ /^ref:/ ? false : true
+    end
+
+    # The current tag. This is only defined if the repository is in "detached
+    # head" mode
+    def self.current_tag() raise "Not yet implemented" end
+
+    # Return true if `version` has an associated tag
+    def self.tag?(version)
+      !list_tags.grep(version).empty?
+    end
+
+    # List tag versions
+    # Create version tag
+    def self.create_tag(version)
+      Command.command "git tag -a 'v#{version}' -m 'Release #{version}'"
+    end
+
+    def self.delete_tag(version, remote: false)
+      Command.command "git tag -d 'v#{version}'", fail: false
+      Command.command("git push --delete origin 'v#{version}'", fail: false) if remote
+    end
+
+    # Checkout a version tag as a detached head
+    def self.checkout_tag(version)
+        Command.command "git checkout 'v#{version}'"
+    end
+
+    def self.list_tags
+      Command.command("git tag").map { |tag| tag.sub(/^v(#{VERSION_SUB_RE})/, '\1') }
+    end
+
+    # Name of the current branch
+    def self.current_branch()
+      Command.command("git rev-parse --abbrev-ref HEAD").first
+    end
+
+    # Check if branch exist
+    def self.branch?(name)
+      Command.command("git show-ref --verify --quiet 'refs/heads/#{name}'", fail: false)
+      Command.status == 0
+    end
+
+    # Create a branch
+    def self.create_branch(name)
+      Command.command "git branch #{name}"
+    end
+
+    # Destroy branch
+    def self.delete_branch(name)
+      Command.command "git branch -D #{name}", fail: false
+    end
+
+    # Check out branch
+    def self.checkout_branch(name, create: false)
+      if create
+        Command.command "git checkout -b #{name}"
+      else
+        Command.command "git checkout #{name}"
+      end
+    end
+
+    # Merge a branch
+    def self.merge_branch(name, exclude_files: [], fail: false)
+      # Save content of excluded files
+      files = {}
+      exclude_files.each { |file|
+        next if !File.exist?(file)
+        files[file] = File.readlines(file)
+      }
+
+      Command.command "git merge --no-commit #{name}", fail: false
+
+      # Reinstate included files
+      files.each { |path, content| 
+        File.open(path, "w") { |file| file.puts(content) }
+        # Resolve git unmerged status
+        Git.add(path)
+      }
+    end
+
+    # List branches
+    def self.list_branches
+      Command.command "git branch --format='%(refname:short)'"
+    end
+
+    # Add a file to the index of the current branch
+    def self.add(*files)
+      Array(files).each { |file|
+        Dir.chdir(File.dirname(file)) {
+          Command.command "git add '#{File.basename(file)}'"
+        }
+      }
+    end
+
+    # Return content of file in the given tag or branch. Defaults to HEAD
+    def self.readlines(file, tag: nil, branch: nil)
+      !(tag && branch) or raise Internal, "Can't use both tag: and branch: options"
+      if tag
+        Command.command "git show v#{tag}:#{file}"
+      else
+        branch ||= "HEAD"
+        Command.command "git show #{branch}:#{file}"
+      end.map { |l| "#{l}\n" }
+    end
+
+    # Return content of file
+    def self.read(file, tag: nil, branch: nil)
+      !(tag && branch) or raise Internal, "Can't use both tag: and branch: options"
+      if tag
+        Command.command "git show v#{tag}:#{file}"
+      else
+        branch ||= "HEAD"
+        Command.command "git show #{branch}:#{file}"
+      end.join("\n")
+    end
+
+    def self.rm(file)
+      Dir.chdir(File.dirname(file)) {
+        Command.command "git rm -f '#{File.basename(file)}'", fail: false
+      }
+    end
+
+    def self.rm_rf(file)
+      Dir.chdir(File.dirname(file)) {
+        Command.command "git rm -rf '#{File.basename(file)}'", fail: false
+      }
+    end
+
+    # Commit changes on the current branch"
+    def self.commit(msg)
+      Command.command "git commit -m '#{msg}'"
+    end
+  end
+end
+

data/lib/prick/migra.rb

@@ -0,0 +1,22 @@
+
+module Prick
+  module Migra
+    def self.migrate(from_name, to_name, file)
+      args = urls(from_name, to_name).join(" ")
+      options = OPTIONS.join(" ")
+      Command.command %(
+        status=0
+        migra #{options} #{args} >#{file} || { status=$?; }
+        [ $status = 2 ] || exit 1
+      )
+    end
+
+  private
+    OPTIONS = %w(--unsafe --with-privileges)
+
+    def self.urls(*args)
+      args = Array(args).flatten
+      args.map { |name| "postgresql:///#{name}" }
+    end
+  end
+end

data/lib/prick/migration.rb

@@ -0,0 +1,230 @@
+
+require 'yaml'
+
+module Prick
+  class Migration
+    KEEP_FILE = ".keep"
+
+    attr_reader :path
+
+    def files() raise AbstractMethod end
+    def release_files() files end
+
+    # Return versions of the features in this migration
+    def feature_versions() raise AbstractMethod end
+
+    def initialize(path, template_dir)
+      @path = path
+      @template_dir = template_dir
+    end
+
+    def exist?() File.exist?(keep_file) end
+    def create() FileUtils.touch_p(keep_file); Git.add(keep_file) end
+    def destroy() Git.rm_rf(path) end
+
+    def present?() exist? && files.all? { |f| File.exist?(f) } end
+    def prepare() files.each { |f| FileUtils.cp(template_file(f), path) }; Git.add(path) end
+
+    def include_feature(feature) raise AbstractMethod end
+
+    def migrate() raise AbstractMethod end
+
+    def to_s() path end
+    def <=>(other) path <=> other.path end
+
+    def self.path(version)
+      if version.feature?
+        File.join(FEATURE_DIR, version.truncate(:feature).to_s, version.feature)
+      else
+        File.join(FEATURE_DIR, version)
+      end
+    end
+
+    def self.version(path)
+      Version.new(path.delete_prefix("#{FEATURE_DIR}/").sub("/", "_"))
+    end
+
+    def self.feature?(path)
+      Version.new(path.delete_prefix("#{FEATURE_DIR}/").sub("/", "_")).feature?
+    end
+
+    def self.files(path) raise AbstractMethod end
+    def self.release_files(path) files(path) end
+
+    def dump(&block)
+#     puts self.class
+#     indent {
+#       puts "path : #{path}"
+#       puts "files: #{files.inspect}"
+#       puts "release_files: #{release_files.inspect}"
+#       puts "feature_versions: #{feature_versions.map(&:to_s).inspect}"
+#       puts "keep_file: #{keep_file}"
+#       yield if block_given?
+#     }
+    end
+
+  protected
+    def template_file(path) File.join(SHARE_PATH, @template_dir, File.basename(path)) end
+    def keep_file() File.join(path, KEEP_FILE) end
+  end
+
+  class ReleaseMigration < Migration
+    FEATURES_TMPL_DIR = "features"
+    FILES = [
+      FEATURES_SQL = "features.sql",
+      FEATURES_YML = "features.yml",
+      MIGRATIONS_SQL = "migrations.sql",
+      DIFF_SQL = "diff.sql"
+    ]
+
+    attr_reader :features_yml
+    attr_reader :features_sql
+    attr_reader :migrations_sql
+    attr_reader :diff_sql
+
+    def files() [features_yml, features_sql, migrations_sql, diff_sql] end
+
+    def initialize(path)
+      super(path, FEATURES_TMPL_DIR)
+      @features_yml = File.join(path, FEATURES_YML)
+      @features_sql = File.join(path, FEATURES_SQL)
+      @migrations_sql = File.join(path, MIGRATIONS_SQL)
+      @diff_sql = File.join(path, DIFF_SQL)
+    end
+
+    def feature_versions() read_features_yml.map { |path| Migration.version(path) } end
+    def feature_paths() read_features_yml end
+
+    # `feature` is a Feature object
+    def include_feature(migration, append: true)
+      migration.is_a?(FeatureMigration) or raise "Expected FeatureMigration object, got #{migration.class}"
+      !feature_paths.include?(migration.path) or raise Error, "Feature #{migration.version} is already included"
+      exclude_files = [Schema.data_file] + 
+          migration.release_files + 
+          migration.feature_paths.map { |path| FeatureMigration.release_files(path) }.flatten
+
+      Git.merge_branch(migration.version, exclude_files: exclude_files)
+      
+      feature_paths = YAML.load(Git.read(migration.features_yml, branch: migration.version))
+      append_features_yml(feature_paths, append: append)
+
+      feature_paths.each { |feature_path|
+        if path != File.dirname(feature_path)
+          FileUtils.ln_s(File.join("../..", feature_path), path)
+          Git.add(File.join(path, File.basename(feature_path)))
+        end
+      }
+    end
+
+    def migrate(database_name)
+      puts "ReleaseMigration#migrate"
+      if File.exist?(migrations_sql)
+        Dir.chdir(path) {
+          puts "  cd #{path}"
+          puts "  psql -d #{database_name} < #{MIGRATIONS_SQL}"
+          Command.command "psql -d #{database_name} < #{MIGRATIONS_SQL}"
+        }
+      end
+    end
+
+
+    def self.files(path)
+      FILES.map { |file| File.join(path, file) }
+    end
+
+    def read_features_yml(branch = nil) YAML.load(File.read(features_yml)) || [] end
+
+    def append_features_yml(paths, append: true)
+      write_features_yml(read_features_yml.insert(append ? -1 : 0, *paths))
+    end
+
+    def write_features_yml(paths)
+      FileUtils.cp(template_file(features_yml), features_yml)
+      File.open(features_yml, "a") { |f| f.write(paths.to_yaml) }
+      FileUtils.cp(template_file(features_sql), features_sql)
+      File.open(features_sql, "a") { |f|
+        paths.map { |path|
+          f.puts "\\cd #{File.basename(path)}"
+          f.puts "\\i migrate.sql" }
+          f.puts "\\cd .."
+          f.puts
+      }
+      Git.add(features_yml)
+      Git.add(features_sql)
+    end
+  end
+
+  class FeatureMigration < Migration
+    FEATURE_TMPL_DIR = "features/feature"
+    FILES = [
+      MIGRATE_SQL = "migrate.sql",
+      DIFF_SQL = "diff.sql"
+    ]
+
+    attr_reader :name
+    attr_reader :version
+    attr_reader :release_migration # The enclosing release migration
+
+    attr_reader :migrate_sql
+    attr_reader :diff_sql
+
+    def features_yml() release_migration.features_yml end
+    def features_sql() release_migration.features_sql end
+    def migrations_sql() release_migration.migrations_sql end
+    def release_diff_sql() release_migration.diff_sql end
+
+    def files() [migrate_sql, diff_sql] end
+    def release_files() release_migration.files end
+
+    def feature_versions() release_migration.feature_versions end
+    def feature_paths() release_migration.feature_paths end
+
+    def initialize(path, name: File.basename(path))
+      Migration.feature?(path) or raise "Expected a feature path, got #{path}"
+      super(path, FEATURE_TMPL_DIR)
+      @name = name
+      @version = Migration.version(path)
+      @release_migration = ReleaseMigration.new(File.dirname(path))
+      @migrate_sql = File.join(path, MIGRATE_SQL)
+      @diff_sql = File.join(path, DIFF_SQL)
+    end
+
+    def exist?() release_migration.exist? && super end
+    def create() 
+      release_migration.exist? || release_migration.create
+      super
+    end
+
+    def present?() release_migration.present? && super end
+    def prepare() 
+      release_migration.present? || release_migration.prepare
+      super
+      release_migration.append_features_yml([path])
+    end
+
+    def include_feature(migration)
+      release_migration.include_feature(migration, append: false)
+    end
+
+    def self.files(path)
+      release_files + FILES.map { |file| File.join(path, file) }
+    end
+
+    def self.release_files(path)
+      ReleaseMigration.files(path)
+    end  
+
+    def dump
+      super {
+        puts "name: #{name}"
+        puts "release_migration: #{path}"
+      }
+    end
+  end
+end
+
+
+
+
+
+