prick 0.19.0 → 0.20.1

data/lib/prick/database.rb

@@ -1,82 +0,0 @@
-
-module Prick
-  class Database
-    attr_reader :name
-    attr_reader :user
-
-    def initialize(name, user)
-      name != "" or raise "Illegal database name" 
-      @name = name
-      @user = user
-      @version = nil
-    end
-
-    def version(cache: true)
-      if cache && @version
-        @version
-      else
-        @version = begin
-            version = 
-                if exist? && Rdbms.exist_table?(name, "prick", "versions")
-                  Rdbms.select(name, "select version from prick.versions")&.first&.first
-                else
-                  nil
-                end
-            version && Version.new(version)
-        end
-      end
-    end
-
-    def version=(version)
-      @version = version && Version.new(version)
-      Rdbms.exec_sql(name, %(
-        update prick.versions
-        set major = '#{@version.major}',
-            minor = '#{@version.minor}',
-            patch = '#{@version.patch}',
-            pre = '#{@version.pre}',
-            version = '#{@version.to_s}'
-      )) if @version
-      @version
-    end
-
-    def exist?() Rdbms.exist_database?(name) end
-    def create() Rdbms.create_database(name, owner: user) end
-    def recreate() drop if exist?; create; @version = nil end
-    def drop() Rdbms.drop_database(name, fail: false); @version = nil end
-
-    def loaded?() !version.nil? end
-
-    def load(file) 
-      !loaded? or raise Internal, "Database #{name} is already loaded"
-      Rdbms.load(name, file, user: user)
-      version # Provoke load of version
-    end
-
-    def save(file) 
-      loaded? or raise Internal, "Database #{name} is not loaded"
-      Rdbms.save(name, file)
-      @version = nil 
-    end
-
-    # Hollow-out a database without dropping it. This is useful compared to a
-    # simple drop database since it wont block on other sessions wont block
-    def clean()
-      if exist?
-        schemas = Rdbms.select_values(
-                      name, 
-                      "select nspname from pg_namespace where nspowner != 10 and nspname != 'prick'")
-        for schema in schemas
-          Rdbms.exec_sql(name, "drop schema \"#{schema}\" cascade")
-        end
-        Rdbms.exec_sql(name, "drop schema if exists public cascade")
-        Rdbms.exec_sql(name, "create schema public authorization postgres")
-        Rdbms.exec_sql(name, "grant usage, create on schema public to public")
-      else
-        create
-      end
-    end
-
-    def to_s() name end
-  end
-end

data/lib/prick/dsort.rb

@@ -1,151 +0,0 @@
-require 'tsort'
-
-module DSort
-  # Thrown if a cyclic dependency is detected
-  #
-  # DSort::Cyclic is inherited from TSort::Cyclic so that recue handling code
-  # written for TSort will still work. It provides a #cycles member that lists
-  # the cycles
-  class Cyclic < TSort::Cyclic
-    # List of detected cycles sorted from shortest to longest cycle
-    attr_reader :cycles
-
-    def initialize(dsort_object)
-      @cycles = 
-          dsort_object.each_strongly_connected_component \
-            .select { |e| e.size > 1 } \
-            .sort { |l,r| r <=> l }
-      gram = cycles.size > 1 ? "ies" : "y"
-      super("Cyclic depedendenc#{gram} detected")
-    end
-  end
-
-  # dsort sorts its input in "dependency" order: The input can be thought of
-  # depends-on relations between objects and the output as sorted in the order
-  # needed to safisfy those dependencies so that no object comes before an
-  # object it depends on
-  #
-  # dsort can take an array or a hash argument, or be supplied with a block
-  #
-  # The Array argument should consist of pairs (two-element Arrays) with the
-  # first element being the depending object and the second an object or an
-  # array of objects it depends on: For example [:a, :b] means that :a depends
-  # on :b, and [:b, [:c, :d]] that :b depends on both :c and :d
-  #
-  # The Hash argument should be a hash from depending object to an object or
-  # array of objects it depends on. If h is a Hash then dsort(h) is equivalent
-  # to dsort(h.to_a)
-  #
-  # Note that if the elements are arrays themselves, then you should use the
-  # array form to list the dependencies even if there is only one dependency.
-  # Ie. use [:a, [:b]] or {:a => [:b] } instead of [:a, :b] or {:a => :b}
-  #
-  # If dsort is given a block, the block is given an element as argument and
-  # should return an (possibly empty) array of the objects the argument depends
-  # on. The argument to dsort should be an element or an array of elements to
-  # be given to the block. Note that if the elements are arrays themselves,
-  # then the arguments to dsort should use the array form even if there is only
-  # one element. Ie.  Use dsort([:a]) instead of dsort(:a)
-  #
-  # dsort raise a DSort::Cyclic exception if a cycle detected 
-  #
-  # Example: If we have that dsort depends on ruby and rspec, ruby depends
-  # on C to compile, and rspec depends on ruby, then in what order should we
-  # build them ? Using dsort we could do
-  #
-  #   p dsort [[:dsort, [:ruby, :rspec]]], [:ruby, :C], [:rspec, :ruby]]
-  #       => [:C, :ruby, :rspec, :dsort]
-  #
-  # Using a hash
-  #
-  #   h = {
-  #     :dsort => [:ruby, :rspec],
-  #     :ruby => [:C],
-  #     :rspec => [:ruby]
-  #   }
-  #   p dsort(h) # Same as dsort(h.to_a)
-  #       => [:C, :ruby, :rspec, :dsort]
-  #
-  # or using a block
-  #
-  #   p dsort(:dsort) { |e| h[e] }
-  #       => [:C, :ruby, :rspec, :dsort]
-  #
-  def dsort(a, &block) 
-    sort_object = DSortPrivate::DSortObject.new(a, &block)
-    begin
-      sort_object.tsort 
-    rescue TSort::Cyclic
-      raise Cyclic.new(sort_object)
-    end
-  end
-
-  # tsort sort its input in topological order: The input can be thought of as
-  # comes-before relations between objects and the output will be in
-  # first-to-last order. This definition corresponds to the mathemacial
-  # defitionnn of topological sort. See
-  # http://en.wikipedia.org/wiki/Topological_sorting
-  #
-  # Arguments are the same as for dsort. tsort is equivalent to
-  # dsort(...).reverse
-  #
-  # tsort raise a DSort::Cyclic exception if a cycle is detected (DSort::Cyclic
-  # is an alias for TSort::Cyclic)
-  #
-  def tsort(a, &block) dsort(a, &block).reverse end
-
-  module_function :dsort, :tsort
-
-  module DSortPrivate
-    class DSortObject
-      include TSort
-
-      # Hash from element to array of dependencies
-      attr_reader :deps
-
-      # Create @deps hash from object to list of dependencies
-      def initialize(a, &block)
-        @deps = {}
-        if block_given?
-          a = [a] if !a.is_a?(Array)
-          a.each { |elem| find_dependencies(elem, &block) }
-        else
-          a.each { |obj, deps| 
-            (@deps[obj] ||= []).concat(deps.is_a?(Array) ? deps : [deps])
-          }
-        end
-
-        # Make sure all dependent objects are also represented as depending
-        # objects: If we're given [:a, :b] we want the @deps hash to include
-        # both :a and :b as keys
-        @deps.values.each { |deps|
-          (deps.is_a?(Array) ? deps : [deps]).each { |d|
-            @deps[d] = [] if !@deps.key?(d)
-          }
-        }
-      end
-
-      # TSort virtual methods
-      def tsort_each_node(&block) @deps.each_key(&block) end
-      def tsort_each_child(node, &block) @deps[node].each(&block) end
-
-    private
-      def find_dependencies(a, &block)
-        block.call(a).each { |d|
-          (@deps[a] ||= []) << d
-          find_dependencies(d, &block)
-        }
-      end
-    end
-  end
-end
-
-
-
-
-
-
-
-
-
-

data/lib/prick/ensure.rb

@@ -1,119 +0,0 @@
-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

@@ -1,25 +0,0 @@
-
-module Prick
-  class Error < RuntimeError; end
-  class Fail < Error; end
-
-  class NotYet < NotImplementedError
-    def initialize() super("Internal error: Not yet implemented") end
-  end
-
-  class NotThis < ScriptError
-    def initialize() super("Internal error: Abstract method called") end
-  end
-
-  class Abstract < ScriptError
-    def initialize() super("Internal error: Abstract method called") end
-  end
-
-  AbstractMethod = Abstract
-
-  class Internal < ScriptError; end
-  class Oops < Internal
-    def initialize() super("Oops, this shouldn't happen") end
-  end
-end
-

data/lib/prick/head.rb

@@ -1,189 +0,0 @@
-
-module Prick
-  class Head
-    def project_name() Prick.project.name end
-
-    # Usually equal to #version.to_s
-    attr_reader :name
-
-    # Version. This should be equal to schema.version
-    attr_reader :version
-
-    def base_version() @migration.base_version end
-
-    attr_reader :schema
-
-    attr_reader :migration
-
-    def clean?() Git::clean? end
-
-    def tag?() false end
-    def release_tag?() false end
-    def migration_tag?() false end
-
-    def branch?() false end
-    def release_branch?() false end
-    def prerelease_branch?() false end
-    def feature_branch?() false end
-    def migration_branch?() false end
-
-    def initialize(name, version, migration)
-      @name = name
-      @version = version
-      @schema = Schema.new
-      @migration = migration
-    end
-
-    # TODO: Handle migrations
-    def self.load(name)
-      version, tag = Version.parse(name)
-      if tag
-        ReleaseTag.load
-      else
-        if version.release?
-          ReleaseBranch.load
-        elsif version.prerelease?
-          PrereleaseBranch.load(version)
-        elsif version.feature?
-          FeatureBranch.load(version)
-        else
-          raise NotHere
-        end
-      end
-    end
-
-    def create() 
-      raise NotThis
-    end
-
-    def build(database)
-      schema.build(database)
-    end
-
-    def self.database_name(version)
-      version.truncate(:pre).to_s
-    end
-  end
-
-  class Tag < Head
-    def tag?() true end
-
-    def initialize(version, base_version, migration = nil)
-      migration ||= Migration.new(version, base_version)
-      super(version.to_s, version, migration)
-    end
-
-    def self.load
-      state = Migration.load
-      self.new(state.version, state.base_version)
-    end
-
-    def create
-      initial_branch_name = "#{version}_initial"
-      clean? or raise Internal, "Repository is not clean"
-      !Git.detached? or raise Internal, "Not on a branch"
-      Git.create_branch(initial_branch_name)
-      Git.checkout_branch(initial_branch_name)
-      migration.update(version)
-      schema.version = version
-      Git.commit "Created release v#{version}"
-      Git.create_tag(version)
-      Git.checkout_tag(version)
-      self
-    end
-  end
-
-  class ReleaseTag < Tag
-    def release_tag?() true end
-  end
-
-  # TODO
-  class PrereleaseTag < Tag
-  end
-
-  class MigrationTag < Tag
-    def migration_tag?() true end
-  end
-
-  class Branch < Head
-    def branch?() true end
-
-    def initialize(name, version, migration)
-      super(name, version, migration)
-    end
-
-    def create() 
-      Git.create_branch(version)
-      Git.checkout_branch(version)
-      migration.create
-      self
-    end
-  end
-
-  class UserBranch < Branch
-    def initialize(name)
-      super(nil, nil, nil)
-    end
-  end
-
-  class ReleaseBranch < Branch
-    def release_branch?() true end
-
-    def initialize(fork = nil, base_version)
-      if fork
-        version = Version.new(base_version, fork: fork)
-      else
-        version = base_version
-      end
-      super(version.to_s, version, Migration.new(nil, base_version))
-    end
-
-    def self.load
-      state = MigrationState.load
-      ReleaseBranch.new(nil, state.base_version)
-    end
-  end
-
-  class PrereleaseBranch < Branch
-    def prerelease_branch?() true end
-
-    def initialize(version, base_version)
-      target_version = version.truncate(:pre)
-      super(version.to_s, target_version, Migration.new(target_version, base_version))
-    end
-
-    def self.load
-      state = MigrationState.load
-      PrereleaseBranch.new(state.version, state.base_version)
-    end
-  end
-
-  class FeatureBranch < Branch
-    def feature_branch?() true end
-
-    def initialize(feature_name, base_version)
-      name = Version.new(base_version, feature: feature_name).to_s
-      super(name, base_version, FeatureMigration.new(feature_name, base_version))
-    end
-
-    def self.load
-      state = MigrationState.load
-      FeatureBranch.new(state.version.feature)
-    end
-  end
-
-  # TODO: Versioned migrations (or maybe not)
-  class MigrationBranch < Branch
-    def migrationn_branch?() true end
-
-    def initialize(version, base_version)
-      if (version.fork || "") == (base_version.fork || "")
-        name = version.to_s + "-" + base_version.semver.to_s
-      else
-        name = version.to_s + "-" + base_version.to_s
-      end
-      super(name, version, Migration.new(version, base_version))
-    end
-  end
-end
-

data/lib/prick/migration.rb

@@ -1,70 +0,0 @@
-
-module Prick
-  class Migration
-    attr_reader :version
-    attr_reader :base_version
-
-    def initialize(version, base_version) 
-      @version = version
-      @base_version = base_version
-    end
-
-    def self.load
-      state = MigrationState.load
-      Migration.new(state.version, state.base_version)
-    end
-
-    # Remove content of the migration/ directory
-    def self.clear
-      FileUtils.empty!(MIGRATION_DIR)
-    end
-
-    def exist?() MigrationState.exist?  end
-
-    def create() 
-      files = Share.cp "migration/*", MIGRATION_DIR
-      state = MigrationState.new.write(version: version, base_version: base_version)
-      Git.add files, state.path
-      self
-    end
-
-    def update(version)
-      state = MigrationState.new.read
-      @version = state.version = version
-      state.write
-      Git.add state.path
-      self
-    end
-
-    def migrate(database) 
-      base_version or raise Internal, "Can't migrate from nil to #{version}"
-      version or raise Internal, "Can't migrate from #{base_version} to nil"
-      MigrationBuilder.new(database, MIGRATION_DIR).build
-    end
-  end
-
-  class FeatureMigration < Migration
-    attr_reader :feature
-
-    def initialize(feature, base_version)
-      super(base_version, base_version)
-      @feature = feature
-    end
-
-    def self.load
-      migration_state = MigrationState.load
-      feature_state = FeatureState.load
-      FeatureMigration.new(feature_state.feature, migration_state.base_version)
-    end
-
-    def create()
-      super
-      files = Share.cp "migration", File.join(MIGRATION_DIR, feature)
-      state = FeatureState.write(feature: feature)
-      Git.add files, state.path
-      self
-    end
-  end
-end
-
-