prick 0.19.0 → 0.20.1

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

data/lib/local/command.rb

@@ -0,0 +1,193 @@
+require 'fcntl'
+
+require 'forward_to'
+
+include ForwardTo
+
+module Command
+  class Error < RuntimeError
+    attr_reader :cmd
+    attr_reader :status
+    attr_reader :stdin
+    attr_reader :stdout
+    attr_reader :stderr
+
+    def initialize(cmd, status, stdin, stdout, stderr)
+      super(stderr.join("\n"))
+      @cmd = cmd
+      @status = status
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+    end
+  end
+
+  class Pipe
+    attr_reader :cmd
+    attr_reader :status
+
+    def writer() @pw[1] end
+    def reader() @pr[0] end
+    def error() @pe[0] end
+
+    forward_to :reader, :read, :gets
+    forward_to :writer, :write, :puts
+
+    # Remaining output not consumed by #get/#read or through #reader or #error
+    attr_reader :stdout
+    attr_reader :stdin
+
+    def initialize(cmd, stderr: nil, fail: true)
+      @cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
+      @stderr = stderr
+      @fail = fail
+
+      @pw = IO::pipe # pipe[0] for read, pipe[1] for write
+      @pr = IO::pipe
+      @pe = IO::pipe
+
+      STDOUT.flush
+
+      @pid = fork {
+        @pw[1].close
+        @pr[0].close
+        @pe[0].close
+
+        STDIN.reopen(@pw[0])
+        @pw[0].close
+
+        STDOUT.reopen(@pr[1])
+        @pr[1].close
+
+        STDERR.reopen(@pe[1])
+        @pe[1].close
+
+        exec(cmd)
+      }
+
+      @pw[0].close
+      @pr[1].close
+      @pe[1].close
+    end
+
+    def wait
+      @pw[1].close
+      @status = Process.waitpid2(@pid)[1].exitstatus
+
+      out = @pr[0].readlines.map(&:chomp)
+      err = @pe[0].readlines.map(&:chomp)
+
+      @pr[0].close
+      @pe[0].close
+
+      raise Command::Error.new(@cmd, @status, nil, out, err) if @status != 0 && @fail == true
+
+      case @stderr
+        when true; [out, err]
+        when false; out
+        when nil
+          $stderr.puts err
+          out
+      end
+    end
+  end
+
+  # Execute the shell command 'cmd' and return standard-output as an array of
+  # strings. If :stdin is a string or an array of lines if will be fed to the
+  # command on standard-input, if it is a IO object that IO object is piped to
+  # the command
+  #
+  # By default #command pass through standard-error but if :stderr is true,
+  # #command will return a tuple of standard-output, standard-error lines. If
+  # :stderr is false, standard-error is ignored and is the same as adding
+  # "2>/dev/null" to the command
+  #
+  # #command raises a Command::Error exception if the command return with an
+  # exit code != 0 unless :fail is false. In that case the the exit code can be
+  # fetched from Command::status
+  #
+  def command(cmd, stdin: nil, stderr: nil, fail: true)
+    cmd = "set -o errexit\nset -o pipefail\n#{cmd}"
+
+    pw = IO::pipe # pipe[0] for read, pipe[1] for write
+    pr = IO::pipe
+    pe = IO::pipe
+
+    STDOUT.flush
+
+    pid = fork {
+      pw[1].close
+      pr[0].close
+      pe[0].close
+
+      STDIN.reopen(pw[0])
+      pw[0].close
+
+      STDOUT.reopen(pr[1])
+      pr[1].close
+
+      STDERR.reopen(pe[1])
+      pe[1].close
+
+      exec(cmd)
+    }
+
+    pw[0].close
+    pr[1].close
+    pe[1].close
+
+    if stdin
+      case stdin
+        when IO; pw[1].write(stdin.read)
+        when String; pw[1].write(stdin)
+        when Array; pw[1].write(stdin.join("\n") + "\n")
+      end
+      pw[1].flush
+      pw[1].close
+    end
+
+    @status = Process.waitpid2(pid)[1].exitstatus
+
+    out = pr[0].readlines.map(&:chomp)
+    err = pe[0].readlines.map(&:chomp)
+
+    pw[1].close if !stdin
+    pr[0].close
+    pe[0].close
+
+    if @status != 0
+      @exception = Command::Error.new(cmd, @status, stdin, out, err)
+      raise @exception if fail
+    else
+      @exception = nil
+    end
+
+    case stderr
+      when true; [out, err]
+      when false; out
+      when nil
+        $stderr.puts err
+        out
+    end
+  end
+
+  # Exit status of the last command
+  def status() @status end
+
+  # Stored exception when #command is called with :fail true
+  def exception() @exception end
+
+  # Like command but returns true if the command exited with the expected
+  # status. Note that it suppresses standard-error by default
+  #
+  def command?(cmd, expect: 0, stdin: nil, stderr: false)
+    command(cmd, stdin: stdin, stderr: stderr, fail: false)
+    @status == expect
+  end
+
+  module_function :command
+  module_function :status
+  module_function :exception
+  module_function :command?
+end
+