xing-root 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1e5c25fdf0a0131b66f61a48b065e7a042edfda
+  data.tar.gz: bdda3cd893b79191835a14ade4ce89b6a63844d5
+SHA512:
+  metadata.gz: e3e77cdf6e85e6108aa2876c879a783e68a97ffc64d3ab4c525d43ce6fb9cf369133f42e01d93dd05b91f12fe954a37a5b396e5365ed86769f1456dad9084467
+  data.tar.gz: 57bb2b0db2a4884c8eef59f885d21241b842e15571a3f34484e25c721be0ca8240824e07e6da660da7400921ae5f76cdd06aee86ae869682c8ef363da489a514

data/lib/xing/edicts/clean-rake.rb

@@ -0,0 +1,16 @@
+require 'edict'
+require 'xing/edicts/clean-run'
+
+module Xing
+  module Edicts
+    class CleanRake < CleanRun
+
+      setting :task_name
+
+      def setup
+        super
+        self.shell_cmd = %w[bundle exec rake] + [task_name]
+      end
+    end
+  end
+end

data/lib/xing/edicts/clean-run.rb

@@ -0,0 +1,40 @@
+require 'caliph'
+require 'edict'
+
+module Xing
+  module Edicts
+    class CleanRun < Edict::Rule
+      include Caliph::CommandLineDSL
+
+      setting :dir
+      setting :shell_cmd
+      setting :env_hash
+      setting :caliph_shell
+
+      def setup_defaults
+        super
+        @caliph_shell = Caliph::Shell.new
+      end
+
+      def setup
+        self.env_hash ||= {}
+      end
+
+      def action
+        Bundler.with_clean_env do
+          Dir.chdir(dir) do
+            command = cmd(*shell_cmd)
+
+            env_hash.each_pair do |name, value|
+              command.set_env(name, value)
+            end
+
+            result = caliph_shell.run(command)
+
+            result.must_succeed!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xing/edicts/launch-browser.rb

@@ -0,0 +1,91 @@
+require 'caliph'
+require 'edict'
+require 'xing-root'
+
+module Xing::Edicts
+  class LaunchBrowser < Edict::Command
+    setting :reload_server_port
+    setting :static_server_port
+    setting :setup_time_limit, 60
+    setting :max_wait, 16
+
+    def initialize
+      self.command = ""
+      super
+    end
+
+    def check_live_reload_server!
+      begin_time = Time.now
+      begin
+        test_conn = TCPSocket.new 'localhost', reload_server_port
+      rescue Errno::ECONNREFUSED
+        if Time.now - begin_time > setup_time_limit
+          puts "Couldn't connect to test server on localhost:#{reload_server_port} after #{setup_time_limit} seconds - bailing out"
+          exit 1
+        else
+          sleep 0.05
+          retry
+        end
+      ensure
+        test_conn.close rescue nil
+      end
+    end
+
+    def check_existing_browser
+      started = Time.now
+      changes = {}
+      while(Time.now - started < max_wait)
+        begin
+          changes = JSON.parse(Net::HTTP.get(URI("http://localhost:#{reload_server_port}/changed")))
+        rescue Errno::ECONNREFUSED
+          puts "LiveReload server abruptly stopped receiving connections. Bailing out."
+          exit 2
+        end
+
+        if changes["clients"].empty?
+          sleep 0.25
+        else
+          break
+        end
+      end
+      changes["clients"]
+    end
+
+    def launch_new_browser
+      puts
+      puts "No running development browsers: launching...."
+
+      browser_command = %w{open xdg-open chrome chromium}.find do |command|
+        run_command(cmd('which', command)).succeeds?
+      end
+
+      if browser_command.nil?
+        raise "Can't find any executable to launch a browser with."
+      end
+
+      run_command( cmd(browser_command, "http://localhost:#{static_server_port}/") ).must_succeed!
+    end
+
+    def subprocess_action
+      require 'net/http'
+      require 'json'
+
+      check_live_reload_server!
+
+      existing = check_existing_browser
+
+      if existing.empty?
+        launch_new_browser
+      else
+        puts
+        puts "There's already a browser attached to the LiveReload server."
+      end
+    end
+
+    def action
+      fork do
+        subprocess_action
+      end
+    end
+  end
+end

data/lib/xing/edicts/start-child.rb

@@ -0,0 +1,11 @@
+module Xing::Edicts
+  class StartChild < Edict::Rule
+    setting :manager
+    setting :label
+    setting :child_task
+
+    def action
+      manager.start_child(label, child_task)
+    end
+  end
+end

data/lib/xing/edicts/structure-checker.rb

@@ -0,0 +1,99 @@
+require 'xing-root'
+require 'find'
+require 'edict'
+
+module Xing::Edicts
+  class StructureChecker < Edict::Rule
+    include Find
+
+    class Error < ::StandardError
+    end
+
+    setting :dir
+    nil_field :context_hash
+    setting :out_stream, $stdout
+
+    def setup
+      @problems = []
+    end
+
+    def action
+      analyze
+      report
+    end
+
+    def analyze
+      context = context_from_hash(context_hash || {:escapes => %w{common framework build}})
+      return unless File.directory?(dir)
+      find(dir) do |path|
+        if File.directory?(path)
+        else
+          next if File.basename(path)[0] == ?.
+          case path
+          when /\.js\z/
+            check_imports(path, context)
+          end
+        end
+      end
+    end
+
+    def context_from_hash(hash)
+      Context.new(hash)
+    end
+
+    def report
+      unless @problems.empty?
+        @problems.group_by do |problem|
+          problem.file
+        end.each do |file, problems|
+          out_stream.puts "In #{file}"
+          problems.each{|prob| out_stream.puts "  " + prob.to_s}
+          out_stream.puts
+        end
+        raise Error, "Problems found in ECMAScript structure"
+      end
+    end
+
+    class Context
+      def initialize(hash)
+        @escape_clause_list = hash.delete(:escapes) || %w{common framework build}
+        raise "Unknown fields in context: #{hash.inspect}" unless hash.empty?
+      end
+
+      attr_reader :escape_clause_list
+    end
+
+    class Problem < ::Struct.new(:msg, :line, :lineno, :file)
+      def to_s
+        "#{lineno}:<#{line}>: #{msg}"
+      end
+    end
+
+    def problem(msg, line, lineno, file)
+      @problems << Problem.new(msg, line.chomp, lineno + 1, file)
+    end
+
+    def check_imports(path, context)
+      File.read(path).lines.grep(/\s*import/).each_with_index do |import_line, lineno|
+        md = /.*from (?<quote>['"])(?<from>.*)\k<quote>/.match(import_line)
+        if md.nil?
+          problem "doesn't seem to have a 'from' clause...", import_line, lineno, path
+        end
+
+        if /\.\./ =~ md[:from]
+          if /\A\.\./ !~ md[:from]
+            problem "from includes .. not at pos 0", import_line, lineno, path
+          end
+          if /\w.*\.\./ =~ md[:from]
+            problem "from includes .. after words", import_line, lineno, path
+          end
+          if !(violation = %r{(?<dir>\w+)/\w}.match md[:from]).nil?
+            unless %r{\.\./(#{context.escape_clause_list.join("|")})} =~ md[:from]
+              problem "Imports Rule: 'from' includes ../ and then #{violation[:dir].inspect} not in #{context.escape_clause_list.inspect}", import_line, lineno, path
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xing/edicts.rb

@@ -0,0 +1,3 @@
+require 'xing/edicts/clean-run'
+require 'xing/edicts/start-child'
+require 'xing/edicts/launch-browser'

data/lib/xing/managers/child.rb

@@ -0,0 +1,110 @@
+class ChildManager
+  def initialize
+    @child_pids = []
+    @parent_pid = Process.pid
+    @child_data = {}
+  end
+  attr_accessor :child_pids, :child_data
+
+  ChildRecord = Struct.new(:name, :status)
+
+  def start_child(name, task)
+    child_pid = Process.fork do
+      Signal.trap("HUP") do
+        puts "Parent exited"
+        exit
+      end
+
+      exec(*(%w{bundle exec rake} + [task]))
+    end
+    puts "#{@parent_pid}: #{name} running in pid #{child_pid}"
+
+    at_exit { kill_child(child_pid) }
+    child_data[child_pid] = ChildRecord.new(name, nil)
+    child_pids << child_pid
+  end
+
+  def exited?(pid)
+    return false unless child_data.has_key?(pid)
+    return true unless child_data[pid].status.nil?
+
+    begin
+      _apid, status = *Process.wait2(pid, Process::WNOHANG | Process::WUNTRACED)
+    rescue Errno::ECHILD
+      return false
+    end
+
+    unless status.nil?
+      child_data[pid].status = status
+      return true
+    end
+    return false
+  end
+
+  def wait_until_dead(pilimit)
+    start = Time.now
+    while Time.now - start < limit
+      Process.waitpid(-1, Process::WNOHANG | Process::WUNTRACED)
+      sleep(0.1)
+    end
+    return false
+  rescue SystemCallError # = no children
+    return true
+  end
+
+  def wait_all
+    Process.waitall
+  end
+
+  def kill_child(pid)
+    unless Process.pid == @parent_pid
+      puts "#{Process.pid} #@parent_pid Not original parent: not killing"
+      return
+    end
+    puts "PID #{Process.pid} is killing child #{pid} #{child_data[pid].name}"
+
+    if exited?(pid)
+      puts "#{pid} #{child_data[pid].name} already exited"
+      return
+    end
+
+    begin
+      Process::kill("TERM", pid)
+    rescue Errno::ESRCH
+      puts "Hm. #{pid} is already gone: dead?"
+      return
+    end
+
+    limit = 10
+    start = Time.now
+    while Time.now - start < limit
+      begin
+        Process::kill(0, pid)
+        sleep(0.1)
+      rescue Errno::ESRCH
+        return
+      end
+    end
+
+    begin
+      Process::kill("KILL", pid)
+    rescue Errno::ESRCH
+      return
+    end
+  end
+
+  def kill_all
+    unless Process.pid == @parent_pid
+      puts "Although #{Process.pid} was asked to kill all, it isn't #@parent_pid the original parent"
+      return
+    end
+    child_pids.each do |pid|
+      kill_child(pid)
+    end
+    previous_term_trap = trap "TERM" do
+      puts "Trapped TERM once"
+      trap "TERM", previous_term_trap
+    end
+    Process::kill("TERM", 0)
+  end
+end

data/lib/xing/managers/tmux.rb

@@ -0,0 +1,188 @@
+require 'caliph'
+
+module Xing
+  module Managers
+    class Tmux
+      include Caliph::CommandLineDSL
+
+      MINIMUM_WINDOW_COLUMNS = 75
+      MINIMUM_WINDOW_LINES = 18
+
+      def initialize(shell=nil)
+        @shell = shell || Tmux.shell
+        @first_child = true
+        @extra_config_path='~/.lrd-dev-tmux.conf'
+      end
+      attr_reader :shell
+
+      class << self
+        def shell
+          @shell ||= Caliph.new
+        end
+
+        def available?
+          shell.run("which", "tmux").succeeds?
+        end
+      end
+
+      def tmux_exe
+        @tmux_exe ||= shell.run("which", "tmux").stdout.chomp
+      end
+
+      def tmux(*cmd)
+        command = cmd(tmux_exe, *cmd)
+        puts command.string_format
+        shell.run(command).stdout.chomp
+      end
+
+      def copied_env_vars
+        %w{PORT_OFFSET GEM_HOME GEM_PATH}
+      end
+
+      def default_env
+        {"PORT_OFFSET" => 0}
+      end
+
+      def session_env
+        Hash[copied_env_vars.map do |varname|
+          varvalue = ENV[varname] || default_env[varname]
+          [varname, varvalue] unless varvalue.nil?
+        end.compact]
+      end
+
+      def env_string
+        session_env.map do |envpair|
+          envpair.join("=")
+        end.join(" ")
+      end
+
+      def rake_command(task)
+        "env #{env_string} bundle exec rake #{task}"
+      end
+
+      def wait_all
+        path = File.expand_path(@extra_config_path)
+        if File.exists?(path)
+          puts "Loading #{path}"
+          tmux "source-file #{path}"
+        else
+          puts "No extra config found at #{path}"
+        end
+
+        tmux "attach-session -d" unless existing?
+      end
+
+      def existing?
+        !(ENV['TMUX'].nil? or ENV['TMUX'].empty?)
+      end
+
+    end
+
+    class TmuxPane < Tmux
+
+      def initialize(shell=nil)
+        super
+        @window_name = "Dev Servers"
+        @pane_count = 0
+        @window_count = 1
+      end
+      attr_accessor :window_name
+
+      def new_window_after
+        @new_window_after ||= calculate_lines_per_window
+      end
+
+      # need to use %x here rather than open a Caliph subshell
+      # won't ahve the same terminal with subshell
+      def tput_lines
+        %x"tput lines".chomp.to_i
+      end
+
+      def tput_cols
+        %x"tput cols".chomp.to_i
+      end
+
+      def calculate_lines_per_window
+        lines = tput_lines
+        min_lines = (ENV["XING_TMUX_MIN_LINES"] || MINIMUM_WINDOW_LINES).to_i
+        min_lines = [1, lines / min_lines].max
+        if calculate_layout == "tiled"
+          min_lines * 2
+        else
+          min_lines
+        end
+      end
+
+      def calculate_layout
+        min_cols = (ENV["XING_TMUX_MIN_COLS"] || MINIMUM_WINDOW_COLUMNS).to_i
+        cols = tput_cols
+        if cols > min_cols * 2
+          "tiled"
+        else
+          "even-vertical"
+        end
+      end
+
+      def open_new_pane(name, task)
+        tmux "new-window -d -n '#{name}' '#{rake_command(task)}' \\; set-window-option remain-on-exit on"
+        tmux "join-pane -d -s '#{name}.0' -t '#{@window_name}.bottom'"
+      end
+
+      def open_first_window(name, task)
+        if tmux('list-windows -F \'#{window_name}\'') =~ /#{name}|#{@window_name}/
+          puts "It looks like there are already windows open for this tmux?"
+          exit 2
+        end
+
+        if existing?
+          tmux "new-window -n '#@window_name' '#{rake_command(task)}' \\; set-window-option remain-on-exit on"
+        else
+          tmux "new-session -d -n '#@window_name' '#{rake_command(task)}' \\; set-window-option remain-on-exit on"
+        end
+      end
+
+      def open_additional_window(name, task)
+        tmux "select-layout -t '#@window_name' #{@layout}"
+        @window_count = @window_count + 1
+        @window_name = "Dev Servers #{@window_count}"
+        tmux "new-window -d -n '#@window_name' '#{rake_command(task)}' \\; set-window-option remain-on-exit on"
+        @pane_count = 0
+      end
+
+      def start_child(name, task)
+        if @first_child
+          open_first_window(name, task)
+        elsif @pane_count >= new_window_after
+          open_additional_window(name, task)
+        else
+          open_new_pane(name, task)
+        end
+        @pane_count = @pane_count + 1
+        @first_child = false
+      end
+
+      def wait_all
+        tmux "select-layout -t '#@window_name' #{@layout}"
+        super
+      end
+    end
+
+    class TmuxWindow < Tmux
+      def start_child(name, task)
+        if @first_child
+          if tmux 'list-windows -F \'#{window_name}\'' =~ /#{name}/
+            puts "It looks like there are already windows open for this tmux?"
+            exit 2
+          end
+        end
+
+        if @first_child and not existing?
+          tmux "new-session -d -n '#{name}' '#{rake_command(task)}' \\; set-window-option remain-on-exit on"
+        else
+          tmux "new-window -n '#{name}' '#{rake_command(task)}' \\; set-window-option remain-on-exit on"
+        end
+        @first_child = false
+      end
+    end
+  end
+end

data/lib/xing/tasks/backend.rb

@@ -0,0 +1,45 @@
+require 'xing/edicts'
+require 'xing/tasks/tasklib'
+
+module Xing
+  module Tasks
+    class Backend < Tasklib
+      default_namespace :backend
+      setting :dir, "backend"
+
+      def define
+        in_namespace do
+          edict_task :bundle_install, Edicts::CleanRun do |bi|
+            bi.shell_cmd = %w{bundle check || bundle install}
+          end
+
+          edict_task :check_dependencies, Edicts::CleanRun do |cd|
+            cd.shell_cmd = %w{bundle exec rake dependencies:check}
+          end
+          task :check_dependencies => :bundle_install
+
+          desc "Migrate database up to current"
+          edict_task :db_migrate, Edicts::CleanRun do |dm|
+            dm.shell_cmd = %w{bundle exec rake db:migrate}
+          end
+          task :db_migrate => :bundle_install
+
+          task :setup => [:bundle_install, :db_migrate]
+
+          edict_task :db_seed, Edicts::CleanRun do |ds|
+            ds.shell_cmd = %w{bundle exec rake db:seed}
+          end
+          task :db_seed => :db_migrate
+
+          desc "Precompile rails assets"
+          edict_task :assets_precompile, Edicts::CleanRun do |ap|
+            ap.shell_cmd = %w{bundle exec rake assets:precompile}
+          end
+          task :assets_precompile => [:bundle_install, :db_migrate]
+
+          task :all => [:db_seed, :assets_precompile]
+        end
+      end
+    end
+  end
+end

data/lib/xing/tasks/build.rb

@@ -0,0 +1,28 @@
+require 'xing/edicts'
+require 'xing/tasks/tasklib'
+
+module Xing
+  module Tasks
+    class Build < Tasklib
+      default_namespace :build
+      setting :config_dir, "../frontend"
+
+      def define
+        in_namespace do
+          task :all => ['frontend:all']
+
+          namespace :frontend do
+            edict_task :grunt_compile, Edicts::CleanRun do |gc|
+              gc.dir = "frontend"
+              gc.env_hash = {"CUSTOM_CONFIG_DIR" => config_dir}
+              gc.shell_cmd = %w{bundle exec node_modules/.bin/grunt compile}
+            end
+            task :grunt_compile => ['frontend:setup']
+
+            task :all => [:grunt_compile]
+          end
+        end
+      end
+    end
+  end
+end