xing-root 0.0.1

data/lib/xing/tasks/develop.rb

@@ -0,0 +1,144 @@
+require 'xing/edicts'
+require 'xing/tasks/tasklib'
+
+module Xing
+  module Tasks
+    class Develop < Tasklib
+      DEFAULT_RELOAD_PORT = 35729
+      DEFAULT_RAILS_PORT  = 3000
+      DEFAULT_MOBILE_PORT = 9000
+      DEFAULT_STATIC_PORT  = 9292
+
+      default_namespace :develop
+
+      setting :port_offset
+      setting :reload_server_port
+      setting :rails_server_port
+      setting :mobile_server_port
+      setting :static_server_port
+      setting :manager
+      setting :config_dir, "../frontend"
+
+      def default_configuration
+        @port_offset ||=
+          begin
+            if !ENV['PORT_OFFSET'].nil?
+              ENV['PORT_OFFSET'].to_i.tap do |offset|
+                puts "Shifting server ports by #{offset}"
+              end
+            else
+              0
+            end
+          end
+
+        @manager ||=
+          begin
+            require 'xing/managers/child'
+            require 'xing/managers/tmux'
+            if Managers::Tmux.available?
+              Managers::TmuxPane.new
+            else
+              ChildManager.new.tap do |mngr|
+                at_exit{ mngr.kill_all }
+              end
+            end
+          end.tap do |mgr|
+            puts "Using #{mgr.class.name}"
+          end
+          super
+      end
+
+      def resolve_configuration
+        super
+        self.reload_server_port = DEFAULT_RELOAD_PORT + port_offset if field_unset?(:reload_server_port)
+        self.rails_server_port  = DEFAULT_RAILS_PORT  + port_offset if field_unset?(:rails_server_port)
+        self.mobile_server_port = DEFAULT_MOBILE_PORT + port_offset if field_unset?(:mobile_server_port)
+        self.static_server_port = DEFAULT_STATIC_PORT + port_offset if field_unset?(:static_server_port)
+      end
+
+      def define
+        in_namespace do
+          desc "Launch a browser connected to a running development server"
+          edict_task :launch_browser, Edicts::LaunchBrowser
+
+          edict_task :grunt_watch, Edicts::StartChild do |gw|
+            gw.manager = manager
+            gw.label = "Grunt"
+            gw.child_task = in_namespace('service:grunt_watch').first
+          end
+
+          edict_task :compass_watch, Edicts::StartChild do |cw|
+            cw.manager = manager
+            cw.label = "Compass"
+            cw.child_task = in_namespace('service:compass_watch').first
+          end
+
+          edict_task :rails_server, Edicts::StartChild do |rs|
+            rs.manager = manager
+            rs.label = "Rails"
+            rs.child_task = in_namespace('service:rails_server').first
+          end
+
+          edict_task :sidekiq, Edicts::StartChild do |sk|
+            sk.manager = manager
+            sk.label = "Sidekiq"
+            sk.child_task = in_namespace('service:sidekiq').first
+          end
+
+          edict_task :static_assets, Edicts::StartChild do |sa|
+            sa.manager = manager
+            sa.label = "Static"
+            sa.child_task = in_namespace('service:static_assets').first
+          end
+
+          namespace :service do
+            edict_task :grunt_watch, Edicts::CleanRun do |gw|
+              gw.dir = "frontend"
+              gw.shell_cmd = %w{bundle exec node_modules/.bin/grunt watch:develop}
+              gw.env_hash = {"CUSTOM_CONFIG_DIR" => config_dir}
+            end
+            task :grunt_watch => 'frontend:setup'
+
+            edict_task :compass_watch, Edicts::CleanRun do |cw|
+              cw.dir = "frontend"
+              cw.shell_cmd = %w{bundle exec compass watch}
+            end
+
+            edict_task :rails_server, Edicts::CleanRun do |rs|
+              words = %w{bundle exec rails server}
+              words << "-p#{rails_server_port}" #ok
+
+              rs.dir = "backend"
+              rs.shell_cmd = words
+            end
+            task :rails_server => 'backend:setup'
+
+            edict_task :sidekiq, Edicts::CleanRun do |sk|
+              sk.dir = "backend"
+              sk.shell_cmd = %w{bundle exec sidekiq}
+            end
+
+            edict_task :static_assets, Edicts::CleanRun do |sa|
+              words = %w{bundle exec rackup}
+              words << "-p#{static_server_port}" #ok
+              words << "static-app.ru"
+
+              sa.dir = "backend"
+              sa.shell_cmd = words
+              sa.env_hash = {"LRD_BACKEND_PORT" => "#{rails_server_port}"}
+            end
+          end
+
+          task :wait do
+            manager.wait_all
+          end
+
+          task :startup => [:grunt_watch, :compass_watch, :sidekiq, :static_assets, :rails_server, :launch_browser]
+
+          task :all => [:startup, :wait]
+        end
+      end
+
+    end
+  end
+end

data/lib/xing/tasks/frontend.rb

@@ -0,0 +1,44 @@
+require 'xing/tasks/tasklib'
+require 'xing/edicts/clean-run'
+require 'xing/edicts/structure-checker'
+
+module Xing
+  module Tasks
+    class Frontend < Tasklib
+      default_namespace :frontend
+      setting :dir, "frontend"
+
+      def define
+        in_namespace do
+          edict_task :npm_install, Edicts::CleanRun do |ni|
+            ni.shell_cmd = %w{npm install}
+          end
+
+          edict_task :bundle_install, Edicts::CleanRun do |bi|
+            bi.shell_cmd = %w{bundle check || bundle install}
+          end
+
+          task :check_dependencies => :npm_install
+
+          task :setup => [:npm_install, :bundle_install]
+
+          namespace :code_structure do
+            edict_task :app, Edicts::StructureChecker do |app|
+              app.dir = 'frontend/src/app'
+            end
+            edict_task :common, Edicts::StructureChecker do |common|
+              common.dir = 'frontend/src/common'
+            end
+            edict_task :framework, Edicts::StructureChecker do |fw|
+              fw.dir = 'frontend/src/framework'
+              fw.context_hash = { :escapes => %w{framework} }
+            end
+          end
+
+          desc "Apply code structure rules to frontend"
+          task :code_structure => %w[code_structure:app code_structure:common code_structure:framework]
+        end
+      end
+    end
+  end
+end

data/lib/xing/tasks/spec.rb

@@ -0,0 +1,79 @@
+require 'xing/edicts'
+require 'xing/tasks/tasklib'
+
+module Xing
+  module Tasks
+    class Spec < Tasklib
+      default_namespace :spec
+      setting :config_dir, "../frontend"
+
+      def define
+        in_namespace do
+          edict_task :grunt_ci_test, Edicts::CleanRun do |gct|
+            gct.dir = "frontend"
+            gct.env_hash = {'CUSTOM_CONFIG_DIR' => config_dir}
+            gct.shell_cmd = %w{bundle exec node_modules/.bin/grunt ci-test}
+          end
+          task :grunt_ci_test => ['build:frontend:all' ]
+
+          namespace :links do
+            %w{index.html assets fonts}.each do |thing|
+              edict_task thing, Edict::Command do |l|
+                l.command = ["ln", "-sfn", "../../frontend/bin/#{thing}", "backend/public/#{thing}"]
+              end
+            end
+          end
+
+          edict_task :prepare_db, Edicts::CleanRun do |pd|
+            pd.dir = "backend"
+            pd.shell_cmd = %w{bundle exec rake db:test:prepare}
+          end
+
+          full_spec_edict = Edicts::CleanRun.new do |eddie|
+            copy_settings_to(eddie)
+            eddie.dir = "backend"
+            eddie.shell_cmd = %w{bundle exec rspec}
+          end
+          task :full, [:spec_files] => [:check_dependencies, 'frontend:code_structure', :grunt_ci_test, 'backend:setup', :prepare_db] do |t, args|
+            if args[:spec_files]
+              full_spec_edict.shell_cmd.push(args[:spec_files])
+            end
+            full_spec_edict.enact
+          end
+
+          desc "Run all feature specs, repeating with each browser width as default"
+          responsivity_edict = Edicts::CleanRun.new do |eddie|
+            copy_settings_to(eddie)
+            eddie.dir = "backend"
+          end
+          task :responsivity, [:spec_files] => ['backend:setup', :prepare_db] do |t, args|
+            %w{mobile small medium desktop}.each do |size|
+              responsivity_edict.shell_cmd = ["bundle", "exec", "rspec", "-o", "tmp/rspec_#{size}.txt"]
+              responsivity_edict.env_hash = {'BROWSER_SIZE' => size}
+              if args[:spec_files]
+                responsivity_edict.shell_cmd.push(args[:spec_files])
+              else
+                responsivity_edict.shell_cmd.push('spec/features')
+              end
+              responsivity_edict.enact rescue true
+            end
+          end
+
+          fast_edict = Edicts::CleanRun.new do |eddie|
+            copy_settings_to(eddie)
+            eddie.dir = "backend"
+            eddie.shell_cmd = %w{bundle exec rspec}
+          end
+          task :fast, [:spec_files] => ['backend:setup', :prepare_db] do |t, args|
+            if args[:spec_files]
+              fast_edict.shell_cmd.push(args[:spec_files])
+            else
+              fast_edict.shell_cmd.push("--tag").push("~type:feature")
+            end
+            fast_edict.enact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xing/tasks/tasklib.rb

@@ -0,0 +1,25 @@
+require 'mattock'
+
+module Xing
+  module Tasks
+    class Tasklib < Mattock::Tasklib
+      def edict_task(name, klass, &block)
+        edict = klass.new do |eddie|
+          copy_settings_to(eddie)
+          yield eddie if block_given?
+        end
+        edict_task = task name do
+          edict.enact
+        end
+
+        # For testing purposes
+        edict_task.instance_variable_set("@edict", edict)
+        def edict_task.edict
+          @edict
+        end
+
+        edict_task
+      end
+    end
+  end
+end

data/lib/xing/tasks.rb

@@ -0,0 +1,8 @@
+#require 'pp'
+#pp $:
+
+require 'xing/tasks/backend'
+require 'xing/tasks/build'
+require 'xing/tasks/develop'
+require 'xing/tasks/frontend'
+require 'xing/tasks/spec'

data/lib/xing-root.rb

@@ -0,0 +1,4 @@
+module Xing
+  module Tasks
+  end
+end

data/spec/edicts/clean_rake_spec.rb

@@ -0,0 +1,43 @@
+require 'xing/edicts/clean-rake'
+#require 'bundler'
+
+describe Xing::Edicts::CleanRake do
+
+  let :mock_shell do
+    instance_double(Caliph::Shell)
+  end
+
+  let :test_line do
+    "test:command"
+  end
+
+  let :command do
+    instance_double(Caliph::CommandLine)
+  end
+
+  let :result do
+    instance_double(Caliph::CommandRunResult)
+  end
+
+  let :test_dir do
+    "test-dir"
+  end
+
+  subject :clean_rake do
+    Xing::Edicts::CleanRake.new do |test|
+      test.dir = test_dir
+      test.task_name = test_line
+      test.caliph_shell = mock_shell
+    end
+  end
+
+  it "should run the command and check output" do
+    expect(Bundler).to receive(:with_clean_env).and_yield
+    expect(Dir).to receive(:chdir).with(test_dir).and_yield
+    allow(clean_rake).to receive(:cmd).with("bundle", "exec", "rake", test_line).and_return(command)
+    allow(mock_shell).to receive(:run).with(command).and_return(result)
+    expect(result).to receive(:must_succeed!)
+
+    clean_rake.enact
+  end
+end

data/spec/edicts/clean_run_spec.rb

@@ -0,0 +1,43 @@
+require 'xing/edicts/clean-run'
+require 'bundler'
+
+describe Xing::Edicts::CleanRun do
+
+  let :mock_shell do
+    instance_double(Caliph::Shell)
+  end
+
+  let :test_line do
+    %w[a test command]
+  end
+
+  let :command do
+    instance_double(Caliph::CommandLine)
+  end
+
+  let :result do
+    instance_double(Caliph::CommandRunResult)
+  end
+
+  let :test_dir do
+    "test-dir"
+  end
+
+  subject :clean_run do
+    Xing::Edicts::CleanRun.new do |test|
+      test.dir = test_dir
+      test.shell_cmd = test_line
+      test.caliph_shell = mock_shell
+    end
+  end
+
+  it "should run the command and check output" do
+    expect(Bundler).to receive(:with_clean_env).and_yield
+    expect(Dir).to receive(:chdir).with(test_dir).and_yield
+    allow(clean_run).to receive(:cmd).with(*test_line).and_return(command)
+    allow(mock_shell).to receive(:run).with(command).and_return(result)
+    expect(result).to receive(:must_succeed!)
+
+    clean_run.enact
+  end
+end

data/spec/edicts/launch-browser_spec.rb

@@ -0,0 +1,91 @@
+require 'json'
+require 'xing/edicts/launch-browser'
+
+describe Xing::Edicts::LaunchBrowser do
+  let :mock_reload_connection do
+    instance_double(TCPSocket)
+  end
+
+  let :reload_server_port do
+    37590
+  end
+
+  let :static_server_port do
+    9292
+  end
+
+  let :reload_uri do
+    URI("http://localhost:#{reload_server_port}/changed")
+  end
+
+  let :static_url do
+    "http://localhost:#{static_server_port}/"
+  end
+
+  let :mock_shell do
+    instance_double(Caliph::Shell)
+  end
+
+  let :which_cmd do
+    instance_double(Caliph::CommandLine)
+  end
+
+  let :launch_cmd do
+    instance_double(Caliph::CommandLine)
+  end
+
+  let :success_result do
+    instance_double(Caliph::CommandRunResult)
+  end
+
+  subject :launch_browser do
+    Xing::Edicts::LaunchBrowser.new do |lb|
+      lb.caliph_shell = mock_shell
+      lb.reload_server_port = reload_server_port
+      lb.static_server_port = static_server_port
+      lb.max_wait = 0.1
+    end
+  end
+
+  before :each do
+    allow(TCPSocket).to receive(:new).with('localhost', reload_server_port).and_return(mock_reload_connection)
+    expect(mock_reload_connection).to receive(:close)
+    allow(Net::HTTP).to receive(:get).with(reload_uri).and_return(changed_json)
+
+    allow(launch_browser).to receive(:cmd).with('which', 'open').and_return(which_cmd)
+    allow(mock_shell).to receive(:run).with(which_cmd).and_return(success_result)
+    allow(success_result).to receive(:succeeds?).and_return(true)
+    allow(success_result).to receive(:must_succeed!).and_return(true)
+
+    allow(launch_browser).to receive(:cmd).with('open', static_url).and_return(launch_cmd)
+  end
+
+  describe "when no browser is running" do
+    let :changed_json do
+      {
+        :clients => []
+      }.to_json
+    end
+
+    it "should launch a new browser" do
+      expect(mock_shell).to receive(:run).with(launch_cmd).and_return(success_result)
+
+      launch_browser.check_required
+      launch_browser.subprocess_action #because fork
+    end
+  end
+
+  describe "when an existing browser is connected" do
+    let :changed_json do
+      {
+        :clients => ["someone else"]
+      }.to_json
+    end
+
+    it "should not launch a new browser" do
+      expect(mock_shell).not_to receive(:run).with(launch_cmd)
+      launch_browser.check_required
+      launch_browser.subprocess_action #because fork
+    end
+  end
+end

data/spec/edicts/start-child_spec.rb

@@ -0,0 +1,30 @@
+require 'xing/edicts/start-child'
+require 'xing/managers/tmux'
+
+describe Xing::Edicts::StartChild do
+  let :manager do
+    instance_double Xing::Managers::TmuxPane
+  end
+
+  let :task_label do
+    "My Cool Task"
+  end
+
+  let :task_name do
+    "my:cool:task"
+  end
+
+  subject :start_child do
+    Xing::Edicts::StartChild.new do |sc|
+      sc.manager = manager
+      sc.label = task_label
+      sc.child_task = task_name
+    end
+  end
+
+  it "should have the manager start a child" do
+    expect(manager).to receive(:start_child).with(task_label, task_name)
+
+    start_child.enact
+  end
+end

data/spec/managers/tmux_spec.rb

@@ -0,0 +1,104 @@
+require 'xing/managers/tmux'
+
+describe Xing::Managers::TmuxPane do
+  let :lines do
+    40
+  end
+
+  let :cols do
+    160
+  end
+
+  before :each do
+    allow(tmux_pane).to receive(:puts)
+  end
+
+  def self.command(name)
+    let name do
+      instance_double(Caliph::CommandLine, name).tap do |cl|
+        allow(cl).to receive(:string_format).and_return("format of #{name}")
+      end
+    end
+  end
+
+  command(:list_cmd)
+  command(:new_session_command)
+
+  let (:mock_shell) { instance_double(Caliph::Shell) }
+  let (:list_result) { instance_double(Caliph::CommandRunResult) }
+  let (:new_session_result) { instance_double(Caliph::CommandRunResult) }
+  let (:which_tmux_result) { instance_double(Caliph::CommandRunResult) }
+
+  let :task_name do
+    "ha:ha:ha"
+  end
+
+  let :tmux_path do
+    "usr/bin/tmux"
+  end
+
+
+  subject :tmux_pane do
+    Xing::Managers::TmuxPane.new(mock_shell)
+  end
+
+  before :each do
+    allow(tmux_pane).to receive(:tput_lines).and_return(lines)
+    allow(tmux_pane).to receive(:tput_cols).and_return(cols)
+
+    allow(tmux_pane).to receive(:existing?).and_return(false, true)
+    allow(list_result).to receive(:stdout).and_return("nothing important")
+    allow(new_session_result).to receive(:stdout).and_return("nothing important")
+    allow(new_session_command).to receive(:string_format).and_return("")
+    allow(which_tmux_result).to receive(:stdout).and_return(tmux_path)
+    allow(which_tmux_result).to receive(:succeeds?)
+    allow(mock_shell).to receive(:run).with("which", "tmux").and_return(which_tmux_result)
+    allow(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Alist-windows})).and_return(list_cmd)
+    allow(mock_shell).to receive(:run).with(list_cmd).and_return(list_result)
+  end
+
+  it "first child gets a new session" do
+    allow(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Anew-session})).and_return(new_session_command)
+
+    expect(mock_shell).to receive(:run).with(new_session_command).and_return(new_session_result)
+    tmux_pane.start_child("something", task_name)
+  end
+
+  describe "second child" do
+    before :each do
+      # create first child
+      allow(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Anew-session})).and_return(new_session_command)
+      allow(mock_shell).to receive(:run).with(new_session_command).and_return(new_session_result)
+      tmux_pane.start_child("something", task_name)
+    end
+
+    command(:new_window_command)
+    command(:join_pane_command)
+
+    it "gets a new pane" do
+      expect(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Anew-window})).and_return(new_window_command)
+      expect(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Ajoin-pane})).and_return(join_pane_command)
+      expect(mock_shell).to receive(:run).with(new_window_command).and_return(new_session_result)
+      expect(mock_shell).to receive(:run).with(join_pane_command).and_return(new_session_result)
+      tmux_pane.start_child("something", task_name)
+    end
+
+    describe "in small terminal" do
+
+      let :lines do
+        15
+      end
+
+      let :cols do
+        40
+      end
+
+      it "gets a new window" do
+        expect(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Anew-window})).and_return(new_window_command)
+        expect(tmux_pane).to receive(:cmd).with(tmux_path, match(%r{\Aselect-layout})).and_return(new_window_command)
+        expect(mock_shell).to receive(:run).with(new_window_command).at_least(:twice).and_return(new_session_result)
+        tmux_pane.start_child("something", task_name)
+      end
+    end
+  end
+end