styoe 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2MwNWU2NDFiOTg0ZjZiZDQyMmMyZGQ1YjA0MmIyODFmNDc0YmZmNg==
+    NWYwZGQ2ODE3NzMwZjk5Y2JiYzM0NmRlMThkYTFlNTQwYzU4MDc2Nw==
   data.tar.gz: !binary |-
-    NzIwZWY4ZTNhMzMwMWM0ZGQ5OTlhZGVlYWJjZjQ4ZTgwODExODc4ZA==
+    MWZmMTAyMzIwMGQ4ZGZhOTlhNTRlMjE0NWNiNjFiMTFlZDZmN2U4MQ==
 SHA512:
   metadata.gz: !binary |-
-    YWY0MDE5OTdjZWYwNGU0OTM5ZWI0NGU1OWFiMThlMjI1YjUzYjMxMDc4NWFi
-    NGUwNzk4YzhkMzExZTQzYzJiODU0ZDdhNmYxODk4YjQ5MGEzMGEyYzc0N2Nj
-    MDIzMWMyZWIxYWIyNzBjOWQzNzY3Yjk1YzhlMWQ4ODVkZmVmMGY=
+    MTVhNzFmNmViZGYzYzI2MGRlZTBiMGE0Y2M4N2QxZWU2MWYxNTllZDNhMTM2
+    ZmYwMjM2OWFkMTVlY2U5ZWQ5ZDUyMzQ1MzAyYjdmZWYyYmZjZTg4ZDQ1OThk
+    YzM4YTE3MTAwNzljYTE2ZjhmNWE1NTBkNGYxMDkxNmRhZDhlZTM=
   data.tar.gz: !binary |-
-    ODdmNDIzNjk5NmFiNTI2OWNhNzZkYTNmYTRhOWI2MGZlYjlhMzRmZGFmYzNj
-    ZDgyZDU0YjRlM2RkYTE0YzQwNmY3ZTgxNTJhMGVhOTk4MTMyYzQyZTIwYzYx
-    Mjk4OTEwOTYwZWYxMDg0N2JmMTE2NmUzODgwYTI1YmIxMTkwYjA=
+    NjVlMWRhZTk3ZWIzMWVjZmVjMmM1NDQ2MTI2ZjNmZjA0YjE5OTBhNGRlZmNl
+    M2M1NGExZWY1NGIzMDFlY2M5ZDNlNjJmZWYyODE0MDVkN2ZiZjhjYjljNzE1
+    OTM1MzJhZjM3NDk2MWY5NzJlZTczMDdmODdjYjAwMjk0NWIwNjg=

data/bin/styoe

@@ -2,11 +2,16 @@
 
 require 'styoe'
 
-launcher = Styoe::Launcher.new
+launcher = Styoe::Launcher.build('.engines', '.engines.pids')
 
-case ARGV[0]
-when '--stop'
-  launcher.stop
-else
-  launcher.start
+begin
+  case ARGV[0]
+  when '--stop'
+    launcher.stop
+  else
+    launcher.start
+  end
+rescue Styoe::ConfigurationNotFound
+  $stderr.puts 'No configuration found. Are you sure you have created a .engines file?'
+  exit(1)
 end

data/features/applications_closing.feature

@@ -17,3 +17,4 @@ Feature: Applications closing
      When I successfully run `styoe`
       And I successfully run `styoe --stop`
      Then a file named "closed" should exist
+      And a file named ".engines.pids" should not exist

data/lib/styoe.rb

@@ -3,20 +3,25 @@ require 'styoe/configuration_resolver'
 require 'styoe/process_launcher'
 
 module Styoe
+  class RunningProcess < Struct.new(:path, :pid)
+  end
+
   class Launcher
-    def initialize(config_resolver = nil, process_launcher = nil)
-      @config_resolver  = config_resolver  || ConfigurationResolver.new
-      @process_launcher = process_launcher || ProcessLauncher.new
+    def initialize(config_resolver, process_launcher)
+      @config_resolver  = config_resolver
+      @process_launcher = process_launcher
+    end
+
+    def self.build(dot_file, pid_file)
+      config_resolver = Styoe::ConfigurationResolver.new(dot_file, pid_file, Styoe::DotFileManager.new)
+      process_launcher = Styoe::ProcessLauncher.new
+
+      self.new(config_resolver, process_launcher)
     end
 
     def start
-      begin
-        processes = Hash[*run_processes]
-        @config_resolver.dump_pids(processes)
-      rescue ConfigurationNotFound
-        $stderr.puts 'No configuration found. Are you sure you have created a .engines file?'
-        exit(1)
-      end
+      running_processes = run_processes!
+      @config_resolver.dump_processes(running_processes)
     end
 
     def stop
@@ -27,10 +32,11 @@ module Styoe
 
     private
 
-    def run_processes
-      @config_resolver.processes.map do |process|
-        [process, @process_launcher.launch(process)]
-      end.flatten
+    def run_processes!
+      @config_resolver.processes.map do |process_path|
+        pid = @process_launcher.launch(process_path)
+        RunningProcess.new(process_path, pid)
+      end
     end
   end
 end

data/lib/styoe/configuration_resolver.rb

@@ -1,48 +1,48 @@
 require 'yaml'
+require 'styoe/dot_file_manager'
 
 module Styoe
-  DOT_FILE = '.engines'
-  PID_FILE = '.engines.pids'
-
-  class ConfigurationNotFound < StandardError; end
-
   class ConfigurationResolver
-    def initialize(options = {})
-      @stop_at = options[:stop_at] || '/'
+    def initialize(dot_filename, pid_filename, dot_file_manager)
+      @dot_filename = dot_filename
+      @pid_filename = pid_filename
+      @dot_file_manager = dot_file_manager
     end
 
-    def active_processes(path = PID_FILE)
-      raise ConfigurationNotFound if stop?(path)
-      return active_processes("../#{path}") unless File.exist?(path)
+    def active_processes
+      file_configuration = @dot_file_manager.find_recursively(@pid_filename)
 
-      parse_values(path)
+      File.delete(file_configuration.path)
+      parse_contents(file_configuration.contents)
     end
 
-    def processes(path = DOT_FILE)
-      raise ConfigurationNotFound if stop?(path)
-      return processes("../#{path}") unless File.exist?(path)
+    def processes
+      file_configuration = @dot_file_manager.find_recursively(@dot_filename)
 
-      parse_values(path)
+      parse_contents(file_configuration.contents)
     end
 
-    def dump_pids(pids, path = DOT_FILE)
-      raise ConfigurationNotFound if stop?(path)
-      return dump_pids(pids, "../#{path}") unless File.exist?(path)
+    def dump_processes(processes)
+      processes_dump = ProcessesDumper.dump(processes)
 
-      file = File.open(path.gsub(DOT_FILE, PID_FILE), "w")
-      file.write(YAML.dump pids)
-      file.close
+      @dot_file_manager.save_near(@dot_filename,
+                                  new_name: @pid_filename,
+                                  contents: processes_dump)
     end
 
-    private
-
-    def parse_values(path)
-      contents = File.read(path)
+    def parse_contents(contents)
       YAML.load(contents).values
     end
+  end
+
+  class ProcessesDumper
+    def self.dump(processes)
+      self.to_hash(processes).to_yaml
+    end
 
-    def stop?(path)
-      File.dirname(File.absolute_path path) == @stop_at
+    def self.to_hash(processes)
+      ary_processes = processes.map { |p| [p.path, p.pid] }.flatten
+      Hash[*ary_processes]
     end
   end
 end

data/lib/styoe/dot_file_manager.rb

@@ -0,0 +1,40 @@
+module Styoe
+  class ConfigurationNotFound < StandardError; end
+
+  class DotFile < Struct.new(:path, :contents)
+    def self.read_from_path(path)
+      contents = File.read(path)
+      self.new(path, contents)
+    end
+  end
+
+  class DotFileManager
+    def find_recursively(path)
+      return DotFile.read_from_path(path) if File.exist?(path)
+      raise ConfigurationNotFound if reached_root?(path)
+
+      find_recursively("../#{path}")
+    end
+
+    def save_near(filename, new_name: "", contents: "")
+      near_file = find_recursively(filename)
+      path_to_save = filename_near(near_file.path, new_name)
+      write_file(path_to_save, contents)
+    end
+
+    private
+
+    def filename_near(path, name)
+      filename  = File.basename(path)
+      path.gsub(filename, name)
+    end
+
+    def write_file(path, contents)
+      File.open(path, 'w') { |f| f.write(contents) }
+    end
+
+    def reached_root?(path)
+      File.dirname(File.absolute_path path) == '/'
+    end
+  end
+end

data/lib/styoe/version.rb

@@ -1,3 +1,3 @@
 module Styoe
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/configuration_resolver_spec.rb

@@ -1,84 +1,62 @@
+require 'styoe'
 require 'styoe/configuration_resolver'
 
 describe Styoe::ConfigurationResolver do
 
-  let(:pids)     { { application1: 1, application2: 2 } }
-  let(:pid_file) { instance_double(File) }
+  let(:dot_filename)     { '.engines' }
+  let(:pid_filename)     { '.engines.pids' }
+  let(:dot_file_manager) { instance_double(Styoe::DotFileManager) }
 
-  it 'resolves and parses a configuration file' do
-    allow_file_to_exist_and_return("#{Styoe::DOT_FILE}", sample_configuration)
+  subject { described_class.new(dot_filename, pid_filename, dot_file_manager) }
 
-    expect(subject.processes).to eq(['hello', 'world'])
-  end
-
-  it 'searches configuration recursively in parent directories' do
-    allow_file_to_exist_and_return("../../#{Styoe::DOT_FILE}", sample_configuration)
+  it 'parses found configuration file' do
+    stub_found_dotfile(dot_filename, sample_configuration)
 
     expect(subject.processes).to eq(['hello', 'world'])
   end
 
-  it 'stops searching configuration when root is reached' do
-    subject = described_class.new(stop_at: '/')
-    allow(File).to receive(:dirname).and_return('/')
+  it 'searches active processes and deletes related pidfile' do
+    stub_found_dotfile(pid_filename, sample_pids)
+    allow(File).to receive(:delete)
 
-    expect { subject.processes }.to raise_error(Styoe::ConfigurationNotFound)
-  end
-
-  it 'searches active processes' do
-    allow_file_to_exist_and_return("#{Styoe::PID_FILE}", sample_pids)
+    active_processes = subject.active_processes
 
-    expect(subject.active_processes).to eq([ 1, 2 ])
+    expect(active_processes).to eq([ 1, 2 ])
+    expect(File).to have_received(:delete).with(pid_filename)
   end
 
-  it 'searches active processes recursively' do
-    allow_file_to_exist_and_return("../../#{Styoe::PID_FILE}", sample_pids)
+  it 'dumps active processes on the same path of dotfile' do
+    allow(dot_file_manager).to receive(:save_near)
+    subject.dump_processes([
+      Styoe::RunningProcess.new("application1", 1),
+      Styoe::RunningProcess.new("application2", 2)
+    ])
 
-    expect(subject.active_processes).to eq([ 1, 2 ])
+    expect(dot_file_manager).to have_received(:save_near)
+                                .with(dot_filename,
+                                      new_name: pid_filename,
+                                      contents: sample_pids)
   end
 
-  it 'stops searching active processes when root is reached' do
-    subject = described_class.new(stop_at: '/')
-    allow(File).to receive(:dirname).and_return('/')
-
-    expect { subject.active_processes }.to raise_error(Styoe::ConfigurationNotFound)
-  end
-
-  it "dumps active processes on the same path of #{Styoe::DOT_FILE}" do
-    pid_file = double
-    pids = { application1: 1, application2: 2 }
-    allow(File).to receive(:exist?).and_return(false, false, true)
-    allow(File).to receive(:open).with("../../#{Styoe::PID_FILE}", "w").and_return(pid_file)
-    allow(YAML).to receive(:dump).with(pids).and_return(sample_pids)
-    allow(pid_file).to receive(:write)
-    allow(pid_file).to receive(:close)
-
-    subject.dump_pids(pids)
-
-    expect(pid_file).to have_received(:write).with(sample_pids)
-    expect(pid_file).to have_received(:close)
-  end
-
-  def allow_file_to_exist_and_return(path, read_file)
-    allow_file_to_exist(path)
-    allow(File).to receive(:read).with(path).and_return(read_file)
-  end
-
-  def allow_file_to_exist(path)
-    allow(File).to receive(:exist?).and_return(false)
-    allow(File).to receive(:exist?).with(path).and_return(true)
-  end
-
-  def sample_configuration
-    <<-config
-    application1: hello
-    application2: world
-    config
-  end
+def sample_configuration
+  <<-pids
+---
+application1: hello
+application2: world
+  pids
+end
 
   def sample_pids
     <<-pids
-    application1: 1
-    application2: 2
+---
+application1: 1
+application2: 2
     pids
   end
+
+  def stub_found_dotfile(path, contents)
+    configuration = Styoe::DotFile.new(path, contents)
+    allow(dot_file_manager).to receive(:find_recursively).with(path).and_return(configuration)
+  end
+
 end

data/spec/{fire_spec.rb → styoe_spec.rb}

@@ -3,20 +3,22 @@ require 'styoe'
 describe Styoe::Launcher do
   let(:configuration_resolver) { instance_double(Styoe::ConfigurationResolver) }
   let(:process_launcher)       { instance_double(Styoe::ProcessLauncher) }
-  let(:processes)              { [ "app1", "app2", "app3" ] }
   let(:pids)                   { [ 1, 2, 3 ] }
-  let(:running_processes)      { Hash[*processes.zip(pids).flatten] }
 
   subject { Styoe::Launcher.new(configuration_resolver, process_launcher) }
 
   it "launches configuration processes and remembers open pids" do
-    allow(configuration_resolver).to receive(:processes).and_return(processes)
-    allow(configuration_resolver).to receive(:dump_pids)
-    stub_processes_launch
+    allow(configuration_resolver).to receive(:processes).and_return(["app1", "app2", "app3"])
+    allow(configuration_resolver).to receive(:dump_processes)
+    stub_processes_launch("app1" => 1, "app2" => 2, "app3" => 3)
 
     subject.start
 
-    expect(configuration_resolver).to have_received(:dump_pids).with(running_processes)
+    expect(configuration_resolver).to have_received(:dump_processes).with([
+      Styoe::RunningProcess.new("app1", 1),
+      Styoe::RunningProcess.new("app2", 2),
+      Styoe::RunningProcess.new("app3", 3)
+    ])
   end
 
   it 'stops active processes' do
@@ -30,8 +32,8 @@ describe Styoe::Launcher do
 
   private
 
-  def stub_processes_launch
-    processes.zip(pids).each do |process, pid|
+  def stub_processes_launch(processes)
+    processes.each do |process, pid|
       allow(process_launcher).to receive(:launch).with(process).and_return(pid)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: styoe
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Antonio Scandurra
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-23 00:00:00.000000000 Z
+date: 2014-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,12 +101,13 @@ files:
 - features/support/env.rb
 - lib/styoe.rb
 - lib/styoe/configuration_resolver.rb
+- lib/styoe/dot_file_manager.rb
 - lib/styoe/process_launcher.rb
 - lib/styoe/version.rb
 - script/bootstrap
 - spec/.gitkeep
 - spec/configuration_resolver_spec.rb
-- spec/fire_spec.rb
+- spec/styoe_spec.rb
 - styoe.gemspec
 homepage: https://github.com/as-cii/styoe
 licenses:
@@ -138,4 +139,4 @@ test_files:
 - features/support/env.rb
 - spec/.gitkeep
 - spec/configuration_resolver_spec.rb
-- spec/fire_spec.rb
+- spec/styoe_spec.rb