port_map 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a9144c963820f3ad67ddaa22b88da961e2089a5d
+  data.tar.gz: 580bdec31873ecad6109a1c005dc510c8e6e14f6
+SHA512:
+  metadata.gz: b96382df0a479e97c2bbcf4a3fbd8ff082d205432dc5d6717ff1aeb9ddd83d2d5496fed1c1801c94b593c3f210ad21d7945b1bf98bf3c01b62e1decaa329de07
+  data.tar.gz: cd928903c386ee429b1ce128201891a5368af59c37e2548ba0f1910d9a8cebfec30216957dc20eca5dd35e2a56e92baa4f9edc77257f42e485137d014db9d0b0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in port_map.gemspec
+gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    port_map (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    codeclimate-test-reporter (0.4.8)
+      simplecov (>= 0.7.1, < 1.0.0)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.3)
+    method_source (0.8.2)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.2)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    simplecov (0.11.2)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  codeclimate-test-reporter
+  port_map!
+  pry (~> 0.10.0)
+  rake (~> 10.0)
+  rspec (~> 3.4.0)
+
+BUNDLED WITH
+   1.10.6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kevin Jalbert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# PortMap
+
+[![Gem Version](https://badge.fury.io/rb/port_map.svg)](https://badge.fury.io/rb/port_map)
+[![Build Status](https://travis-ci.org/kevinjalbert/port_map.svg?branch=master)](https://travis-ci.org/kevinjalbert/port_map)
+[![Code Climate](https://codeclimate.com/github/kevinjalbert/port_map/badges/gpa.svg)](https://codeclimate.com/github/kevinjalbert/port_map)
+[![Test Coverage](https://codeclimate.com/github/kevinjalbert/port_map/badges/coverage.svg)](https://codeclimate.com/github/kevinjalbert/port_map/coverage)
+
+
+During web development you are constantly running/starting/stoping local web servers. This isn't a huge problem when dealing with a single web server. As you run more web servers at the same time (i.e., microservices) the complexity jumps as you have to manually account for the ports each will be running on. This gem aims at simplifying the managment of web servers as well as exposing named domains for each web server. In addition, it takes advantage of nginx as the underlying web server.
+
+## Example Scenario
+
+### The Setup
+You are developing a service that uses multiple web servers. You have two rails applications and one ember application.
+
+| Application | Directory | Command | Local URL |
+|-------------|-----------|---------|-----------|
+Rails API | `/api/` | `rails server` | http://localhost:3000
+Rails Background Jobs | ``/jobs/`` | `rails server --port 3001` | http://localhost:3001
+Ember Application | `/ember/` | `ember server` | http://localhost:4200
+
+### The Problem
+In each of these applications there is some configuration work required to ensure that they communicate on the correct ports. There are two issues here:
+
+- As we add more web servers we have to avoid clashing on existing ports.
+- You have to make sure that you correctly start each server with the right port number.
+
+### `port_map` to the Rescue!
+We're going to transform this unwieldly scenario into an organized and easy to manage one using `port_map`.
+
+| Application | Directory | Command | Local URL |
+|-------------|-----------|---------|-----------|
+Rails API | `/api/` | `port_map rails server` | http://api.dev
+Rails Background Jobs | ``/jobs/`` | `port_map rails server` | http://jobs.dev
+Ember Application | `/ember/` | `port_map ember server` | http://ember.dev
+
+The domain names can be configured with environment variables, but by default they are based on the directory's name.
+
+You can close and restart each web server multiple times and they will continue to use the same domain names. `port_map` provides an easy way to logically name each web server, as well as remove the need of specifying ports.
+
+## Assumptions and Dependencies
+
+1. You have the nginx web server installed
+2. You are able to run nginx with sudo (this is required as we're listening on the protected port 80)
+3. You have `include servers/*;` within your `nginx.conf` within the `http` block
+4. (optional) Allow nginx command to be ran without password prompt (add command to sudoers via `visudo`)
+
+## Installation
+
+```
+gem install port_map
+```
+
+## Commands
+Installing this gem provides four executable commands:
+
+### `create_port_map`
+- `create_port_map 3000`
+  - _Add proxy mapping http://127.0.0.1:3000/ to http://directory_name.dev_
+  1. A generated nginx configuration is created under nginx's servers directory (`/usr/local/etc/nginx/servers/directory_name.port_map.conf`).
+  2. Update `/etc/hosts` with new entry `127.0.0.1 directory_name.dev #port_map`.
+  3. Reloads nginx -- `sudo nginx -s reload`.
+- `create_port_map 3000 <specified_name>`
+  - _Add proxy mapping http://127.0.0.1:3000/ to http://specified_name.dev_
+  1. A generated nginx configuration is created under nginx's servers directory (`/usr/local/etc/nginx/servers/specified_name.port_map.conf`).
+  2. Update `/etc/hosts` with new entry `127.0.0.1 specified_name.dev #port_map`.
+  3. Reloads nginx -- `sudo nginx -s reload`.
+
+### `list_port_maps`
+- `list_port_maps`
+  - List a parsable JSON payload of the current port maps that are managed.
+```
+[
+  {
+    "name": "api",
+    "nginx_conf": "/usr/local/etc/nginx/servers/api.port_map.conf",
+    "server_name": "api.dev",
+    "locations": [
+      {
+        "name": "/",
+        "proxy_pass": "http://127.0.0.1:3000"
+      }
+    ]
+  }
+]
+```
+
+### `remove_port_map`
+- `remove_port_map <specified_name>`
+  - _Removed proxy mapping of specified_name.dev/ to http://127.0.0.1:3000_
+  1. Removes the nginx config generated from `create_port_map`.
+  2. Removes the hosts entry generated from `create_port_map`.
+  3. Reloads nginx -- `sudo nginx -s reload`.
+
+### `port_map`
+- `port_map <command>`
+  1. Adjusts/Adds a dynamic port number on command (assuming command takes `-p <number>` or `--port <number>`).
+  2. Executes `create_port_map <dynamic_port_number>`
+    1. Uses a `.port_map.conf` nginx server configuration (with a `$PORT` placeholder present), for generated nginx configuration.
+    2. Using a name specified in the `PORT_MAP_NAME` environment variable.
+    1. Using a name specified from the current directory.
+  3. Updates `/etc/hosts` with new entry `127.0.0.1 determined_name.dev #port_map`.
+  4. Reloads nginx -- `sudo nginx -s reload`.
+  5. Executes `<command>`.
+  6. Executes `remove_port_map <determined_name>`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kevinjalbert/port_map. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/create_port_map

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+require 'port_map'
+
+port = ARGV[0]
+
+unless (1..65535).cover?(port.to_i)
+  raise 'a valid port number must be provided as the first argument'
+end
+
+server_conf = nil
+if File.exist?(PortMap::NginxConf::PORT_MAP_CONF_FILENAME)
+  server_conf = PortMap::NginxConf.from_file(port, File.new(PortMap::NginxConf::PORT_MAP_CONF_FILENAME))
+else
+  name = ARGV[1] || Dir.pwd.split('/').last
+  server_conf = PortMap::NginxConf.new(port, name)
+end
+server_conf.save
+
+PortMap::Hosts.update
+
+puts "Add proxy mapping http://127.0.0.1:#{server_conf.port}/ to http://#{server_conf.server_name}"
+
+PortMap::Nginx.reload

data/bin/list_port_maps

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'port_map'
+
+puts JSON.pretty_generate(PortMap::Mappings.all)

data/bin/port_map

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+require 'port_map'
+
+port = PortMap::Utilities.next_empty_port
+name = ENV['PORT_MAP_NAME']
+
+success = system("create_port_map #{port} #{name}")
+raise 'exception occurred during `create_port_map`' unless success
+
+port_removed = false
+
+Signal.trap('INT') do
+  system("remove_port_map #{name}")
+  port_removed = true
+end
+
+Signal.trap('TERM') do
+  system("remove_port_map #{name}")
+  port_removed = true
+end
+
+cmd = PortMap::Utilities.apply_open_port_option(port, ARGV.join(' '))
+system(PortMap::Utilities.shell_cmd_wrapper(cmd))
+
+at_exit do
+  system("remove_port_map #{name}") unless port_removed
+end

data/bin/remove_port_map

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'port_map'
+
+name = ARGV[0] || Dir.pwd.split('/').last
+
+port_map = PortMap::Mappings.all.detect do |element|
+  element[:name] == name
+end
+
+raise "There are no port-maps matching #{name}" if port_map.nil?
+raise "#{port_map[:nginx_conf]} does not exist" unless File.exist?(port_map[:nginx_conf])
+
+File.delete(port_map[:nginx_conf])
+
+PortMap::Hosts.update
+
+port_map[:locations].each do |location|
+  puts "Removed proxy mapping of #{port_map[:server_name]}#{location[:name]} to #{location[:proxy_pass]}"
+end
+
+PortMap::Nginx.reload

data/lib/port_map/hosts.rb

@@ -0,0 +1,27 @@
+module PortMap
+  module Hosts
+    PORT_MAP_TRACK_COMMENT = '#port_map'.freeze
+    HOSTS_FILENAME = '/etc/hosts'.freeze
+
+    def self.update
+      new_contents = contents
+      port_maps = JSON.parse(`list_port_maps`)
+
+      unless port_maps.empty?
+        new_contents += "\n127.0.0.1 #{port_maps.map { |port_map| port_map['server_name'] }.join(' ')} #{PORT_MAP_TRACK_COMMENT}"
+      end
+
+      save(new_contents)
+    end
+
+    def self.save(new_contents)
+      File.open(HOSTS_FILENAME, 'w+') { |f| f.write(new_contents) }
+    end
+
+    def self.contents
+      File.readlines(HOSTS_FILENAME).reject do |line|
+        line.strip.match(/#{PORT_MAP_TRACK_COMMENT}$/)
+      end.join
+    end
+  end
+end

data/lib/port_map/mappings.rb

@@ -0,0 +1,25 @@
+module PortMap
+  module Mappings
+    def self.parse_conf(filename)
+      contents = File.new(filename).read
+      server_name = contents.match(/server_name\s+(.+?);/)
+      location_mappings = contents.scan(/location\s+(.+?)\s+{\s+proxy_pass\s+(.+?);\s+}/m)
+
+      data = {}
+      data[:name] = File.basename(filename, '.port_map.conf')
+      data[:nginx_conf] = PortMap::Nginx.servers_directory + File::Separator + data[:name] + '.port_map.conf'
+      data[:server_name] = server_name.captures.first
+      data[:locations] = location_mappings.map do |location_mapping|
+        { name: location_mapping.first, proxy_pass: location_mapping.last }
+      end
+
+      data
+    end
+
+    def self.all
+      Dir.glob(PortMap::Nginx.servers_directory + File::Separator + '/*.port_map.conf').map do |filename|
+        parse_conf(filename)
+      end
+    end
+  end
+end

data/lib/port_map/nginx.rb

@@ -0,0 +1,24 @@
+module PortMap
+  module Nginx
+    def self.conf_directory
+      return ENV.fetch('NGINX_DIR') if ENV.key?('NGINX_DIR')
+
+      _, stdout, stderr = Open3.popen3('nginx -t')
+      location_match = [stdout.read, stderr.read].join.match(/nginx: the configuration file (.+?) syntax/)
+
+      if location_match && !location_match.captures.empty?
+        Pathname.new(location_match.captures.first).dirname.to_s
+      else
+        raise '`nginx -t` command did not reveal nginx conf. You can set NGINX_DIR environment variable to indicate nginx conf directory'
+      end
+    end
+
+    def self.servers_directory
+      conf_directory + File::Separator + 'servers'
+    end
+
+    def self.reload
+      `sudo nginx -s reload`
+    end
+  end
+end

data/lib/port_map/nginx_conf.rb

@@ -0,0 +1,59 @@
+module PortMap
+  class NginxConf
+    DOMAIN = 'dev'.freeze
+    PORT_PLACEHOLDER = '$PORT'.freeze
+    PORT_MAP_CONF_FILENAME = '.port_map.conf'.freeze
+
+    attr_reader :name,
+                :port,
+                :domain,
+                :output
+
+    def self.from_file(port, file)
+      file_content = file.read
+
+      raise "File #{file} does not contain special $PORT placeholder" unless file_content.include?(PORT_PLACEHOLDER)
+      file_content = file_content.sub(PORT_PLACEHOLDER, port)
+
+      name, domain = file_content.match(/server_name\s+(.+)\.(.+?);/).captures
+      new(port, name, domain, file_content)
+    end
+
+    def initialize(port, name, domain = DOMAIN, existing_conf_content = '')
+      @name = name
+      @port = port
+      @domain = domain
+
+      if existing_conf_content.empty?
+        @output = default_conf_content
+      else
+        @output = existing_conf_content
+      end
+    end
+
+    def default_conf_content
+      %(
+        server {
+          listen       80;
+          server_name  #{@name}.#{DOMAIN};
+
+          location / {
+              proxy_pass http://127.0.0.1:#{@port};
+          }
+        }
+      )
+    end
+
+    def server_name
+      "#{@name}.#{@domain}"
+    end
+
+    def filename
+      Nginx.servers_directory + File::Separator + @name + '.port_map.conf'
+    end
+
+    def save
+      File.open(filename, 'w+') { |f| f.write(@output) }
+    end
+  end
+end

data/lib/port_map/utilities.rb

@@ -0,0 +1,43 @@
+module PortMap
+  module Utilities
+    BASH_SHELL = '/bin/bash'.freeze
+    ZSH_SHELL = '/bin/zsh'.freeze
+
+    BASH_CMD_STRING = "bash -c 'source ~/.bashrc > /dev/null; PATH=%{path}; shopt -s expand_aliases; %{cmd}"
+    ZSH_CMD_STRING = "zsh -c 'source ~/.zshrc > /dev/null; PATH=%{path}; setopt aliases; eval %{cmd}'"
+
+    STARTING_PORT_NUMBER = 20000
+    PORT_NUMBER_INCREMENT = 100
+
+    def self.shell_cmd_wrapper(cmd)
+      case ENV.fetch('SHELL')
+      when ZSH_SHELL
+        ZSH_CMD_STRING % { path: ENV.fetch('PATH'), cmd: cmd }
+      when BASH_SHELL
+        BASH_CMD_STRING % { path: ENV.fetch('PATH'), cmd: cmd }
+      else
+        cmd
+      end
+    end
+
+    def self.apply_open_port_option(port, cmd)
+      port_option_flag = '--port'
+
+      if cmd.sub!(/-p\s+(\d+)/, '')
+        port_option_flag = '-p'
+      elsif cmd.sub!(/--port\s+(\d+)/, '')
+        port_option_flag = '--port'
+      end
+
+      [cmd.strip, port_option_flag, port].join(' ')
+    end
+
+    def self.next_empty_port
+      highest_port = PortMap::Mappings.all.map do |port_map|
+        port_map[:locations].detect { |location| location[:name] == '/' }[:proxy_pass].split(':').last.to_i
+      end.sort.reverse.first
+
+      highest_port.nil? ? STARTING_PORT_NUMBER : highest_port + PORT_NUMBER_INCREMENT
+    end
+  end
+end

data/lib/port_map/version.rb

@@ -0,0 +1,3 @@
+module PortMap
+  VERSION = '0.1.0'
+end

data/lib/port_map.rb

@@ -0,0 +1,8 @@
+require 'pathname'
+require 'open3'
+require 'json'
+
+Dir.glob(File.dirname(__FILE__) + '/**/*.rb') { |file| require file }
+
+module PortMap
+end

data/port_map.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'port_map/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'port_map'
+  spec.version       = PortMap::VERSION
+  spec.authors       = ['Kevin Jalbert']
+  spec.email         = ['kevin.j.jalbert@gmail.com']
+
+  spec.summary       = 'Provides an easy and mostly automatic way of mapping ports to local domains'
+  spec.description   = 'Provides an easy and mostly automatic way of mapping ports to local domains'
+  spec.homepage      = 'https://github.com/kevinjalbert/port_map/'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['**/*']
+  spec.test_files    = Dir['{test,spec,features}/**/*']
+  spec.executables   = Dir['bin/*'].map { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.4.0'
+  spec.add_development_dependency 'pry', '~> 0.10.0'
+end

data/spec/port_map/hosts_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+RSpec.describe PortMap::Hosts do
+  describe '.update' do
+    let(:contents) { 'line' }
+    let(:expected_contents) { [contents, "127.0.0.1 #{servers.join(' ')} #{described_class::PORT_MAP_TRACK_COMMENT}"].join("\n") }
+    let(:port_maps) { servers.map { |server| { 'server_name' => server } } }
+
+    before do
+      allow(described_class).to receive(:contents) { contents }
+      allow(JSON).to receive(:parse) { port_maps }
+    end
+
+    context 'with no port_maps' do
+      let(:servers) { [] }
+      let(:expected_contents) { contents }
+
+      it 'does not change the contents' do
+        expect(described_class).to receive(:save).with(expected_contents)
+        described_class.update
+      end
+    end
+
+    context 'with one port_map' do
+      let(:servers) { ['server_a'] }
+
+      it 'adds server and port map track comment' do
+        expect(described_class).to receive(:save).with(expected_contents)
+        described_class.update
+      end
+    end
+
+    context 'with multiple port_maps' do
+      let(:servers) { ['server_a', 'server_b'] }
+
+      it 'adds servers and port map track comment' do
+        expect(described_class).to receive(:save).with(expected_contents)
+        described_class.update
+      end
+    end
+  end
+
+  describe '#save' do
+    let(:temp_dir) { Dir.mktmpdir }
+    let(:temp_file) { File.new(temp_dir + File::Separator + 'hosts', 'w+') }
+    let(:content) { 'example_content' }
+
+    before { stub_const('PortMap::Hosts::HOSTS_FILENAME', temp_file.path) }
+    after { FileUtils.rm_rf(temp_dir) }
+
+    it 'saves output(default conf) to filename' do
+      described_class.save(content)
+      expect(temp_file.read).to eq(content)
+    end
+  end
+
+  describe '.contents' do
+    before { allow(File).to receive(:readlines).with(PortMap::Hosts::HOSTS_FILENAME) { content } }
+
+    context 'content has no port map track comment' do
+      let(:content) { ['normal line', 'line with no comment'] }
+
+      it 'returns all lines of content' do
+        expect(described_class.contents).to eq(content.join)
+      end
+    end
+
+    context 'content has port map track comment' do
+      let(:content) { ['normal line', "line with port map track comment #{described_class::PORT_MAP_TRACK_COMMENT}"] }
+
+      it 'returns all lines of content' do
+        expect(described_class.contents).to eq(content.first)
+      end
+    end
+  end
+end

data/spec/port_map/mappings_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe PortMap::Mappings do
+  describe '.parse_conf' do
+    let(:port) { '3000' }
+    let(:name) { 'admin' }
+    let(:domain) { 'dev' }
+
+    let(:nginx_conf) { PortMap::NginxConf.new(port, name, domain).tap(&:save) }
+    let(:temp_dir) { Dir.mktmpdir }
+
+    before { allow(PortMap::Nginx).to receive(:servers_directory) { temp_dir } }
+    after { FileUtils.rm_rf(temp_dir) }
+
+    it 'parses correctly' do
+      data = described_class.parse_conf(nginx_conf.filename)
+      expect(data[:name]).to eq(name)
+      expect(data[:nginx_conf]).to eq(nginx_conf.filename)
+      expect(data[:server_name]).to eq(nginx_conf.server_name)
+      expect(data[:locations].first[:name]).to eq('/')
+      expect(data[:locations].first[:proxy_pass]).to eq("http://127.0.0.1:#{port}")
+    end
+  end
+
+  describe '.all' do
+    let(:temp_dir) { Dir.mktmpdir }
+
+    before do
+      allow(PortMap::Nginx).to receive(:servers_directory) { temp_dir }
+      File.open(temp_dir + File::Separator + 'admin.port_map.conf', 'w')
+      File.open(temp_dir + File::Separator + 'api.port_map.conf', 'w')
+    end
+
+    after { FileUtils.rm_rf(temp_dir) }
+
+    it 'calls parse_conf for each port_map.conf' do
+      expect(described_class).to receive(:parse_conf).twice
+      described_class.all
+    end
+  end
+end

data/spec/port_map/nginx_conf_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+RSpec.describe PortMap::NginxConf do
+  describe '.from_file' do
+    let(:port_placeholder) { '$PORT' }
+    let(:port) { '3000' }
+    let(:name) { 'admin' }
+    let(:domain) { 'dev' }
+
+    let(:temp_dir) { Dir.mktmpdir }
+    let(:temp_file) do
+      File.new(temp_dir + File::Separator + 'temp.conf', 'w+').tap do |file|
+        file.write(content)
+        file.rewind
+      end
+    end
+    let(:content) do
+      %(
+        server {
+          listen       80;
+          server_name  #{name}.#{domain};
+
+          location / {
+              proxy_pass http://127.0.0.1:#{port_placeholder};
+          }
+        }
+      )
+    end
+
+    after { FileUtils.rm_rf(temp_dir) }
+
+    context 'file has no $PORT placeholder' do
+      let(:port_placeholder) { '$NOT_PORT' }
+      it { expect { described_class.from_file(port, temp_file) }.to raise_error(StandardError) }
+    end
+
+    context 'file has $PORT placeholder' do
+      let(:port_placeholder) { '$PORT' }
+      it { expect { described_class.from_file(port, temp_file) }.not_to raise_error }
+    end
+
+    it 'creates conf from file' do
+      conf = described_class.from_file(port, temp_file)
+      expect(conf.port).to eq(port)
+      expect(conf.name).to eq(name)
+      expect(conf.domain).to eq(domain)
+      expect(conf.output).to eq(content.gsub(port_placeholder, port))
+    end
+  end
+
+  describe '#initialize' do
+    let(:port) { 3000 }
+    let(:name) { 'admin' }
+    let(:domain) { 'dev' }
+
+    context 'without existing_conf_content' do
+      it 'sets output to default_conf_content' do
+        conf = described_class.new(port, name)
+        expect(conf.output).to eq(conf.default_conf_content)
+      end
+    end
+
+    context 'with existing_conf_content' do
+      let(:existing_conf_content) { 'example conf config' }
+
+      it 'sets output to existing_conf_content' do
+        conf = described_class.new(port, name, domain, existing_conf_content)
+        expect(conf.output).to eq(existing_conf_content)
+      end
+    end
+  end
+
+  describe '#default_conf_content' do
+    let(:name) { 'admin' }
+    let(:port) { '3000' }
+    let(:domain) { 'dev' }
+    let(:default_config) do
+      %(
+        server {
+          listen       80;
+          server_name  #{name}.#{domain};
+
+          location / {
+              proxy_pass http://127.0.0.1:#{port};
+          }
+        }
+      )
+    end
+
+    it 'should return a default conf' do
+      conf = described_class.new(port, name, domain)
+      expect(conf.output).to eq(default_config)
+    end
+  end
+
+  describe '#server_name' do
+    let(:name) { 'admin' }
+    let(:port) { '3000' }
+    let(:domain) { 'dev' }
+
+    it 'returns server_name' do
+      conf = described_class.new(port, name, domain)
+      expect(conf.server_name).to eq("#{name}.#{domain}")
+    end
+  end
+
+  describe '#filename' do
+    let(:name) { 'admin' }
+    let(:port) { '3000' }
+    let(:temp_dir) { '/temp' }
+
+    before { allow(PortMap::Nginx).to receive(:servers_directory) { temp_dir } }
+
+    it 'returns filename' do
+      conf = described_class.new(port, name)
+      expect(conf.filename).to eq(temp_dir + File::Separator + name + '.port_map.conf')
+    end
+  end
+
+  describe '#save' do
+    let(:name) { 'admin' }
+    let(:port) { '3000' }
+    let(:temp_dir) { Dir.mktmpdir }
+
+    before { allow(PortMap::Nginx).to receive(:servers_directory) { temp_dir } }
+    after { FileUtils.rm_rf(temp_dir) }
+
+    it 'saves output(default conf) to filename' do
+      conf = described_class.new(port, name)
+      conf.save
+      expect(File.exist?(conf.filename)).to be true
+      expect(File.new(conf.filename).read).to eq(conf.default_conf_content)
+    end
+  end
+end

data/spec/port_map/nginx_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+RSpec.describe PortMap::Nginx do
+  describe '.conf_directory' do
+    context 'env var NGINX_DIR is not set' do
+      context 'nginx is not installed' do
+        let(:cmd_output) { 'zsh: command not found: nginx' }
+
+        before { allow(Open3).to receive(:popen3).with('nginx -t') { [nil, double(read: ''), double(read: cmd_output)] } }
+
+        it 'raises exception' do
+          expect { described_class.conf_directory }.to raise_error(StandardError)
+        end
+      end
+
+      context 'nginx is installed' do
+        let(:nginx_dir) { '/usr/local/etc/nginx' }
+        let(:cmd_output) do
+          [
+            "nginx: the configuration file #{nginx_dir}/nginx.conf syntax is ok",
+            "nginx: configuration file #{nginx_dir}/nginx.conf test is successful"
+          ].join("\n")
+        end
+
+        before { allow(Open3).to receive(:popen3).with('nginx -t') { [nil, double(read: ''), double(read: cmd_output)] } }
+
+        it 'returns nginx_dir' do
+          expect(described_class.conf_directory).to eq(nginx_dir)
+        end
+      end
+    end
+
+    context 'env var NGINX_DIR is set' do
+      let(:nginx_dir) { '/temp' }
+      before do
+        allow(ENV).to receive(:key?).with('NGINX_DIR') { true }
+        allow(ENV).to receive(:fetch).with('NGINX_DIR') { nginx_dir }
+      end
+
+      it 'returns nginx_dir' do
+        expect(described_class.conf_directory).to eq(nginx_dir)
+      end
+    end
+  end
+
+  describe '.servers_directory!' do
+    before { allow(described_class).to receive(:conf_directory) { '/temp/' } }
+
+    it 'returns servers directory' do
+      expect(described_class.servers_directory).to eq(described_class.conf_directory + File::Separator + 'servers')
+    end
+  end
+end

data/spec/port_map/utilities_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+
+RSpec.describe PortMap::Utilities do
+  describe '.shell_cmd_wrapper' do
+    let(:cmd) { 'rails server' }
+    let(:example_path) { 'example_path' }
+
+    before { allow(ENV).to receive(:fetch).with('PATH') { example_path } }
+
+    context 'zsh shell' do
+      before { allow(ENV).to receive(:fetch).with('SHELL') { described_class::ZSH_SHELL } }
+
+      it 'returns zsh cmd' do
+        zsh_cmd = described_class.shell_cmd_wrapper(cmd)
+        expected_zsh_cmd = described_class::ZSH_CMD_STRING % { path: example_path, cmd: cmd }
+        expect(zsh_cmd).to eq(expected_zsh_cmd)
+      end
+    end
+
+    context 'bash shell' do
+      before { allow(ENV).to receive(:fetch).with('SHELL') { described_class::BASH_SHELL } }
+
+      it 'returns bash cmd' do
+        bash_cmd = described_class.shell_cmd_wrapper(cmd)
+        expected_bash_cmd = described_class::BASH_CMD_STRING % { path: example_path, cmd: cmd }
+        expect(bash_cmd).to eq(expected_bash_cmd)
+      end
+    end
+  end
+
+  describe '.apply_open_port_option' do
+    let(:cmd) { "example_cmd -t 30 --num 60 #{port_flag} #{port_number}" }
+
+    let(:port_flag) { '--port' }
+    let(:port_number) { 3000 }
+
+    let(:expected_cmd) { "example_cmd -t 30 --num 60 #{expected_port_flag} #{expected_port_number}" }
+    let(:expected_port_number) { 10000 }
+
+    before { allow(described_class).to receive(:next_empty_port) { expected_port_number } }
+
+    context 'with --port in cmd' do
+      let(:expected_port_flag) { '--port' }
+
+      it { expect(described_class.apply_open_port_option(expected_port_number, cmd)).to eq(expected_cmd) }
+    end
+
+    context 'with -p in cmd' do
+      let(:port_flag) { '-p' }
+      let(:expected_port_flag) { '-p' }
+
+      it { expect(described_class.apply_open_port_option(expected_port_number, cmd)).to eq(expected_cmd) }
+    end
+
+    context 'with no port option in cmd' do
+      let(:port_flag) { nil }
+      let(:port_number) { nil }
+      let(:expected_port_flag) { '--port' }
+
+      it { expect(described_class.apply_open_port_option(expected_port_number, cmd)).to eq(expected_cmd) }
+    end
+  end
+
+  describe '.next_empty_port' do
+    let(:port_mappings) { [] }
+
+    before { allow(PortMap::Mappings).to receive(:all) { port_mappings } }
+
+    context 'no port mappings exist' do
+      it 'returns STARTING_PORT_NUMBER' do
+        expect(described_class.next_empty_port).to eq(described_class::STARTING_PORT_NUMBER)
+      end
+    end
+
+    context 'one port mapping exist' do
+      context 'with one location' do
+        let(:previous_highest_port_number) { 30000 }
+        let(:port_mappings) do
+          [
+            {
+              name: 'admin',
+              nginx_conf: '/usr/local/etc/nginx/servers/admin.port_map.conf',
+              server_name: 'admin.dev',
+              locations: [
+                {
+                  name: '/',
+                  proxy_pass: "http://127.0.0.1:#{previous_highest_port_number}"
+                }
+              ]
+            }
+          ]
+        end
+
+        it 'returns STARTING_PORT_NUMBER' do
+          expect(described_class.next_empty_port).to eq(previous_highest_port_number + described_class::PORT_NUMBER_INCREMENT)
+        end
+      end
+
+      context 'with multiple locations' do
+        let(:previous_highest_port_number) { 30000 }
+        let(:port_mappings) do
+          [
+            {
+              name: 'admin',
+              nginx_conf: '/usr/local/etc/nginx/servers/admin.port_map.conf',
+              server_name: 'admin.dev',
+              locations: [
+                {
+                  name: '/',
+                  proxy_pass: "http://127.0.0.1:#{previous_highest_port_number}"
+                },
+                {
+                  name: '/test',
+                  proxy_pass: 'http://test.dev'
+                }
+              ]
+            }
+          ]
+        end
+
+        it 'returns STARTING_PORT_NUMBER' do
+          expect(described_class.next_empty_port).to eq(previous_highest_port_number + described_class::PORT_NUMBER_INCREMENT)
+        end
+      end
+    end
+
+    context 'multiple port mappings exist' do
+      let(:previous_highest_port_number) { 30000 }
+      let(:port_mappings) do
+        [
+          {
+            name: 'admin',
+            nginx_conf: '/usr/local/etc/nginx/servers/admin.port_map.conf',
+            server_name: 'admin.dev',
+            locations: [
+              {
+                name: '/',
+                proxy_pass: 'http://127.0.0.1:20720'
+              }
+            ]
+          },
+          {
+            name: 'api',
+            nginx_conf: '/usr/local/etc/nginx/servers/api.port_map.conf',
+            server_name: 'api.dev',
+            locations: [
+              {
+                name: '/',
+                proxy_pass: "http://127.0.0.1:#{previous_highest_port_number}"
+              }
+            ]
+          }
+        ]
+      end
+
+      it 'returns STARTING_PORT_NUMBER' do
+        expect(described_class.next_empty_port).to eq(previous_highest_port_number + described_class::PORT_NUMBER_INCREMENT)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'port_map'

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: port_map
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin Jalbert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+description: Provides an easy and mostly automatic way of mapping ports to local domains
+email:
+- kevin.j.jalbert@gmail.com
+executables:
+- create_port_map
+- list_port_maps
+- port_map
+- remove_port_map
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/create_port_map
+- bin/list_port_maps
+- bin/port_map
+- bin/remove_port_map
+- lib/port_map.rb
+- lib/port_map/hosts.rb
+- lib/port_map/mappings.rb
+- lib/port_map/nginx.rb
+- lib/port_map/nginx_conf.rb
+- lib/port_map/utilities.rb
+- lib/port_map/version.rb
+- pkg/port_map-0.1.0.gem
+- port_map.gemspec
+- spec/port_map/hosts_spec.rb
+- spec/port_map/mappings_spec.rb
+- spec/port_map/nginx_conf_spec.rb
+- spec/port_map/nginx_spec.rb
+- spec/port_map/utilities_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kevinjalbert/port_map/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Provides an easy and mostly automatic way of mapping ports to local domains
+test_files:
+- spec/port_map/hosts_spec.rb
+- spec/port_map/mappings_spec.rb
+- spec/port_map/nginx_conf_spec.rb
+- spec/port_map/nginx_spec.rb
+- spec/port_map/utilities_spec.rb
+- spec/spec_helper.rb