prick 0.18.0 → 0.20.2

data/lib/builder/builder.rb

@@ -0,0 +1,122 @@
+require 'local/command'
+
+require 'builder/node.rb'
+require 'builder/node_pool.rb'
+require 'builder/batch.rb'
+require 'builder/parser.rb'
+
+include Constrain
+
+module Prick
+  module Build
+    class Error < StandardError; end
+    class PostgresError < Error; end
+
+    class Builder
+      # PgConn object
+      attr_reader :conn
+
+      # Root schema directory
+      attr_reader :dir
+
+      # Reflections YAML file
+      attr_reader :reflections_file
+
+      # True if database is initially clean - ie. all tables are empty
+      attr_accessor :clean
+
+      # Root build node
+      attr_reader :root
+
+      # Pool of nodes. Initialized by #load_pool
+      attr_reader :pool
+
+      forward_to :pool, :nodes, :decl_nodes, :init_nodes, :term_nodes,
+                        :seed_nodes, :fox_seed_nodes, :sql_seed_nodes,
+                        :schemas
+
+      def batches() @batches ||= group end
+
+      def initialize(conn, dir, clean = true, touched: false)
+        @conn = conn
+        @dir = dir
+        @reflections_file = REFLECTIONS_PATH
+        @clean = clean
+        @pool = NodePool.new
+        @root = Parser.parse(conn, dir)
+        load_pool(@root) # Collect nodes into pool
+        @batches = nil # Initialized by #group
+      end
+
+      # Group sources into batches
+      def group
+        @batches = []
+        kind = nil
+        batch = nil
+
+        for node in [init_nodes, decl_nodes, fox_seed_nodes, sql_seed_nodes, term_nodes].flatten
+          case node.kind
+            when :module
+              if batch&.kind != :module
+                @batches << batch if batch
+                batch = ModuleBatch.new(self)
+              end
+            when :exe # Exe sources always create a new batch
+              @batches << batch if batch
+              batch = SqlBatch.new(self)
+            when batch&.kind
+              ;
+            when :sql || node.kind == :inline
+              if batch&.kind != :exe
+                @batches << batch if batch
+                batch = SqlBatch.new(self)
+              end
+            when :inline
+              @batches << batch if batch
+              batch = SqlBatch.new(self)
+            when :fox
+              @batches << batch if batch
+              batch = FoxBatch.new(self)
+            when :yml
+              next
+          else
+            raise Error, "Unexpected node kind: #{node.kind}"
+          end
+          batch.nodes << node
+        end
+        @batches << batch if batch
+      end
+
+      def execute(conn, create_schemas: schemas)
+        group if batches.nil?
+        conn.exec create_schemas.grep_v("public").map { |schema| "create schema #{schema}" }
+        for batch in batches
+          batch.execute
+        end
+      end
+
+#     def setup
+#     end
+
+#     def teardown
+#     end
+
+      def dump
+        batches ? batches.each(&:dump) : pool.dump
+      end
+
+    private
+      def load_pool(build_node)
+        pool.add(build_node.init_nodes)
+        build_node.decl_nodes.each { |node| 
+          pool.add node
+          load_pool(node) if node.kind == :yml
+        }
+        pool.add(build_node.seed_nodes)
+        pool.add(build_node.term_nodes)
+      end
+    end
+  end
+end
+
+

data/lib/builder/node.rb

@@ -0,0 +1,189 @@
+module Prick
+  module Build
+    class Node
+      attr_reader :parent
+      forward_to :parent, :conn
+      attr_reader :phase # :init, :decl, :seed, :term or nil (for BuildNode)
+      attr_reader :kind # :sql, :exe, :fox, :yml, :inline, :module
+      attr_reader :path
+      attr_reader :args # only defined for :exe (String)
+
+      def name() @name = File.basename(path) end
+
+      def schema() @schema ||= parent&.schema || "public" end
+      def schema=(s) @schema = s end
+
+      attr_reader :source
+
+      def source
+        @source ||= read_source
+      end
+
+      def prefix_lines() 0 end
+
+      def source_lines()
+        return @source_lines if @source_lines
+        source
+        @source_lines
+      end
+
+      def lines() prefix_lines + source_lines end
+
+      def initialize(parent, phase, kind, path, args = nil) 
+        constrain parent, BuildNode, NilClass
+        constrain phase, :init, :decl, :seed, :term, nil
+        constrain kind, :sql, :exe, :fox, :yml, :inline, :module
+        constrain path, String, NilClass
+        @parent, @phase, @kind, @path = parent, phase, kind, path
+        @args = args&.empty? ? nil : args
+        @schema = nil
+        @source_lines = nil
+      end
+
+      def to_s() [path, args].compact.join(" ") end
+      def inspect() to_s end
+      def dump() puts "#{inspect} (#{schema})" end
+
+    protected
+      def read_source
+        @source_lines = 0
+        @source = []
+      end
+    end
+
+    class SqlNode < Node
+      def initialize(parent, phase, path)
+        super(parent, phase, :sql, path)
+      end
+
+    protected
+      def read_source
+        file = File.read(path)
+        @source_lines = 1 + 1 + file.count("\n")
+        ["set search_path to #{schema};\n", file]
+      end
+    end
+
+    class FoxNode < Node
+      def initialize(parent, phase, path)
+        super(parent, phase, :fox, path)
+      end
+    end
+
+    # Note that #path refers to the build file
+    class InlineNode < Node
+      attr_reader :stmts
+
+      def initialize(parent, phase, path, *stmts)
+        super(parent, phase, :inline, path)
+        @stmts = Array(stmts).flatten
+      end
+
+      def inspect() "#@path \"#{@stmts.join(";")}\"" end
+
+    protected
+      def read_source
+        @source_lines = @stmts.size
+        @stmts
+      end
+    end
+
+    class ModuleNode < Node
+      attr_reader :klass
+      attr_reader :command
+      def object() self.class.objects[klass] end
+
+      def initialize(parent, phase, path, klass, command, args = nil)
+        constrain klass, Symbol, String
+        constrain command, Symbol, String
+
+        super(parent, phase, :module, path, args)
+
+        @klass = klass.to_sym
+        @command = command.to_sym
+
+        if !object
+          Kernel.class_eval File.read(path)
+          self.class.objects[@klass] = eval(klass.to_s).new(conn)
+        end
+      end
+
+      def call() 
+        object.send(@command, *args)
+      end
+
+      def inspect() "#{path} #{klass}##{command}" end
+
+    private
+      # Map from klass name (a Symbol) to object
+      @@objects = {}
+      def self.objects() @@objects end
+    end
+
+    class ExeNode < Node
+      # Using a pipe instead of just executing the command shaves off some
+      # deciseconds spent starting up bash. It expects the process to read
+      # database/username from standard input
+      attr_reader :pipe
+
+      def initialize(parent, phase, path, args = nil)
+        super(parent, phase, :exe, path, args)
+        @pipe = Command::Pipe.new(to_s, stderr: nil)
+      end
+
+      def inspect() "#{path}(#{args.join(", ")})" end
+
+    protected
+      def read_source
+        pipe.puts [conn.name, conn.user]
+        sql = pipe.wait
+        @source_lines = 1 + 1 + sql.count("\n")
+        ["set search_path to #{schema};\n", sql]
+      end
+    end
+
+    class BuildNode < Node
+      def nodes() @nodes ||= init_nodes + decl_nodes + seed_nodes + term_nodes end
+
+      attr_reader :decl_nodes
+      attr_reader :init_nodes
+      attr_reader :term_nodes
+      attr_reader :seed_nodes
+
+      def initialize(parent, path)
+        super(parent, nil, :yml, path)
+        @decl_nodes = []
+        @init_nodes = []
+        @term_nodes = []
+        @seed_nodes = []
+      end
+
+      def inspect() to_s end
+
+      def dump
+        puts "BuildNode #{path}"
+        indent {
+          puts "schema: #{schema}" if schema
+          decl_nodes.each(&:dump)
+          for kind in [:init, :term, :seed]
+            kind_nodes = self.send("#{kind}_nodes".to_sym)
+            if !kind_nodes.empty?
+              puts "#{kind.upcase}:"
+              indent { kind_nodes.each(&:dump) } 
+            end
+          end
+        }
+      end
+    end
+
+    class RootBuildNode < BuildNode
+      attr_reader :conn
+
+      def initialize(conn, path)
+        @conn = conn
+        super(nil, path)
+      end
+    end
+  end
+end
+

data/lib/builder/node_pool.rb

@@ -0,0 +1,105 @@
+module Prick
+  module Build
+    class NodePool
+      def schemas() @schemas.keys end
+      def before_schema(s) schemas.take_while { |schema| schema != s } end
+      def after_schema(s) schemas.reverse.take_while { |schema| schema != s }.reverse end
+
+      attr_reader :nodes
+
+      attr_reader :init_nodes
+      attr_reader :decl_nodes
+      attr_reader :seed_nodes
+      attr_reader :term_nodes
+
+      # attr_reader :setup_nodes
+      # attr_reader :teardown_nodes
+
+      def fox_seed_nodes() seed_nodes.select { |node| node.kind == :fox } end
+      def sql_seed_nodes() seed_nodes.select { |node| node.kind == :sql } end
+
+      def initialize() 
+        self.clear
+      end
+
+      def add(*nodes)
+        nodes = Array(nodes).flatten
+        @nodes.concat(nodes)
+        nodes.each { |node| 
+          @schemas[node.schema] += 1
+          @kind_nodes[node.phase]&.append(node)
+        }
+        self
+      end
+
+      def delete(*nodes)
+#       puts "#delete(*nodes)"
+        nodes = Array(nodes).flatten
+        nodes.each { |node|
+          delete_node(node)
+          kind_nodes = @kind_nodes[node.phase] and kind_nodes.delete_at(kind_nodes.index(node))
+        }
+        nodes.last
+      end
+
+      def delete_if(phase = nil, &block)
+        candidates = @kind_nodes[phase] || @nodes
+        delete(candidates.select { |node| yield(node) })
+      end
+
+      def delete_schema(*schemas, exclude: [])
+        schemas = Array(schemas).flatten
+        delete_if { |node| 
+          schemas.include?(node.schema) && !exclude.include?(node.phase) && !exclude.include?(node.kind)
+        }
+      end
+
+      def clear(*phases)
+        phases = Array(phases).flatten
+        if !phases.empty?
+          for phase in phases
+            nodes = @kind_nodes[phase]
+            nodes.each { |node| delete_node(node) }
+            @kind_nodes[phase].clear
+          end
+        else
+          @schemas = Hash.new(0) # map from schema name to number of nodes
+          @nodes = []
+          @init_nodes = []
+          @decl_nodes = []
+          @seed_nodes = []
+          @term_nodes = []
+          @kind_nodes = {
+            decl: @decl_nodes,
+            init: @init_nodes,
+            seed: @seed_nodes,
+            term: @term_nodes,
+            yml: nil
+          }
+        end
+      end
+
+      def dump
+        puts "NodePool, #{nodes.size} nodes"
+        indent {
+          puts "init_nodes:"
+          indent { @init_nodes.each &:dump }
+          puts "decl_nodes:"
+          indent { @decl_nodes.each &:dump }
+          puts "seed_nodes:"
+          indent { @seed_nodes.each &:dump }
+          puts "term_nodes:"
+          indent { @term_nodes.each &:dump }
+        }
+      end
+
+    private
+      def delete_node(node)
+#       puts "#delete_node"
+        @nodes.delete_at(@nodes.index(node))
+        @schemas[node.schema] -= 1
+        @schemas.delete(node.schema) if @schemas[node.schema] == 0
+      end
+    end
+  end
+end

data/lib/builder/parser.rb

@@ -0,0 +1,120 @@
+module Prick
+  module Build
+    class Parser
+      def self.parse(conn, dir)
+        Parser.new(conn).parse(dir).unit
+#       [parser.unit, parser.schemas]
+      end
+
+      attr_reader :conn
+      attr_reader :dir
+      attr_reader :unit
+#     attr_reader :schemas
+
+      def initialize(conn)
+        @conn = conn
+      end
+
+      def parse(dir)
+        @dir = dir
+#       @schemas = {}
+        parse_directory(nil, dir)
+        self
+      end
+
+    private
+
+      # First build unit is a RootBuildNode, the rest are regular BuildNode objects
+      def make_build_unit(parent, path)
+        if @unit
+          BuildNode.new(parent, path)
+        else
+          @unit = RootBuildNode.new(conn, path)
+        end
+      end
+
+      def parse_directory(parent, dir)
+        build_file = "#{dir}/build.yml".sub(/\/\//, "/")
+        if File.exist? build_file
+          parse_build_file(parent, dir, build_file)
+        else
+          raise Error, "Can't find build.yml in #{dir}"
+        end
+      end
+
+      def parse_build_file(parent, dir, path)
+        unit = make_build_unit(parent, path)
+        entries = YAML.load(File.read(path)) || []
+        entries.each { |entry|
+          if entry.is_a?(Hash)
+            entry.each { |key, value|
+              if key == "schema"
+                unit.schema = value
+#               @schemas[unit.schema = value] = true
+              else
+                case key
+                  when "init"; unit.init_nodes
+                  when "term"; unit.term_nodes
+                  when "seed"; unit.seed_nodes
+                else
+                  raise Error, "Illegal key in #{unit.path}: #{key}"
+                end.concat(Array(value).map { |value| parse_entry(unit, key.to_sym, dir, value) })
+              end
+            }
+          else
+            node = parse_entry(unit, :decl, dir, entry)
+            if node.kind == :fox
+              unit.seed_nodes << node
+            else
+              unit.decl_nodes << node
+            end
+          end
+        }
+        unit
+      end
+
+      def parse_entry(unit, phase, dir, entry)
+        if entry.is_a?(Hash)
+          entry.size == 1 or raise Error, "sql and module are single-line values"
+          key, value = entry.first
+          case key
+            when "sql"; InlineNode.new(unit, phase, unit.path, value)
+            when "call"; 
+              args = value.split(/\s+/)
+              args.size >= 3 or raise "Illegal number of arguments: #{value}"
+              file, klass, command, args = *args
+              ModuleNode.new(unit, phase, "#{dir}/#{file}", klass, command, args)
+          else
+            raise Error, "Illegal key: #{key}"
+          end
+        else
+          name = entry
+          name.sub!(/\/$/, "")
+          if name =~ /^(\S+)\s+(.*)$/ # exe
+            file = $1
+            args = $2
+          else
+            file = name
+          end
+          path = "#{dir}/#{file}"
+          if File.directory? path
+            parse_directory(unit, path)
+          elsif File.executable? path
+            ExeNode.new(unit, phase, path, args)
+          elsif File.file? path
+            case path
+              when /\.sql$/
+                SqlNode.new(unit, phase, path)
+              when /\.fox$/
+                FoxNode.new(unit, :seed, path)
+            else
+              raise Error, "Unrecognized file type #{File.basename(path)} in #{unit.dir}"
+            end
+          else
+            raise Error, "Can't find #{name} in #{dir} from #{unit}"
+          end
+        end
+      end
+    end
+  end
+end