docker-compose-api 1.0.0

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+
+rvm: 
+  - 2.2.0
+
+sudo: required
+
+dist: trusty
+
+services:
+  - docker
+
+install:
+  - bundle install
+
+script:
+  - bundle exec rspec

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in docker-compose-api.gemspec
+gemspec
+
+# Code climate coverage support
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Mauricio S. Klein
+
+MIT License
+
+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,69 @@
+[![Build Status](https://travis-ci.org/mauricioklein/docker-compose-api.svg?branch=develop)](https://travis-ci.org/mauricioklein/docker-compose-api)
+[![Code Climate](https://codeclimate.com/github/mauricioklein/docker-compose-api/badges/gpa.svg)](https://codeclimate.com/github/mauricioklein/docker-compose-api)
+[![Test Coverage](https://codeclimate.com/github/mauricioklein/docker-compose-api/badges/coverage.svg)](https://codeclimate.com/github/mauricioklein/docker-compose-api/coverage)
+
+# Docker Compose Api
+
+Docker Compose API provides an easy way to parse docker compose files and lift the whole environment.
+
+## Instalation
+
+```ruby
+# Add the line below on your Gemfile...
+gem 'docker-compose-api', git: 'https://github.com/mauricioklein/docker-compose-api'
+
+# ... and run bundle install
+bundle install
+```
+
+## Usage
+
+```ruby
+require 'docker-compose'
+
+# Docker compose is simply a layer running over Docker client (https://github.com/swipely/docker-api).
+# So, all Docker specific configurations, such URL, authentication, SSL, etc, must be made directly on
+# Docker client.
+#
+# Docker compose provides an easy way to access this client:
+DockerCompose.docker_client
+
+# Gem version
+DockerCompose.version
+
+# Loading a compose file
+compose = DockerCompose.load('[path to docker compose file]')
+
+# Accessing containers
+compose.containers                     # access all containers
+compose.containers['[container name]'] # access a specific container
+
+# Starting containers (and their dependencies)
+compose.start                                    # start all containers
+compose.start(['container1', 'container2', ...]) # start a list of specific containers
+
+# Stopping containers
+# (ps: container dependencies will keep running)
+compose.stop                                    # stop all containers
+compose.stop(['container1', 'container2', ...]) # stop a list of specific containers
+
+# Killing containers
+# (ps: container dependencies will keep running)
+compose.kill                                    # kill all containers
+compose.kill(['container1', 'container2', ...]) # kill a list of specific containers
+
+# Checking if a container is running or not
+a_container = compose.containers['a_container']
+a_container.running?
+
+# Accessing container informations
+a_container.stats
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/mauricioklein/docker-compose-api/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/docker-compose-api.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "docker-compose-api"
+  spec.version       = DockerCompose.version
+  spec.authors       = ["Mauricio S. Klein"]
+  spec.email         = ["mauricio.klein.msk@gmail.com"]
+  spec.summary       = %q{A simple ruby client for docker-compose api}
+  spec.description   = %q{A simple ruby client for docker-compose api}
+  spec.homepage      = "https://github.com/mauricioklein/docker-compose-api"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "docker-api", "~> 1.22.2"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rspec"
+end

data/lib/docker-compose.rb

@@ -0,0 +1,53 @@
+require_relative 'docker-compose/models/compose'
+require_relative 'docker-compose/models/compose_container'
+require_relative 'version'
+
+require 'yaml'
+require 'docker'
+
+module DockerCompose
+  #
+  # Get Docker client object
+  #
+  def self.docker_client
+    Docker
+  end
+
+  #
+  # Load a given docker-compose file.
+  # Returns a new Compose object
+  #
+  def self.load(filepath)
+    unless File.exist?(filepath)
+      puts("Compose file doesn't exists")
+      raise ENOENT
+    end
+
+    compose = Compose.new
+
+    _compose_entries = YAML.load_file(filepath)
+    _compose_entries.each do |entry|
+      compose.add_container(create_container(entry))
+    end
+
+    # Perform containers linkage
+    compose.link_containers
+
+    compose
+  end
+
+  def self.create_container(attributes)
+    ComposeContainer.new({
+      label: attributes[0],
+      image: attributes[1]['image'],
+      build: attributes[1]['build'],
+      links: attributes[1]['links'],
+      ports: attributes[1]['ports'],
+      volumes: attributes[1]['volumes'],
+      command: attributes[1]['command'],
+      environment: attributes[1]['environment']
+    })
+  end
+
+  private_class_method :create_container
+end

data/lib/docker-compose/models/compose.rb

@@ -0,0 +1,86 @@
+require 'docker'
+require_relative 'compose_port'
+require_relative '../utils/compose_utils'
+
+class Compose
+  attr_reader :containers
+
+  def initialize
+    @containers = {}
+  end
+
+  public
+
+  #
+  # Add a new container to compose
+  #
+  def add_container(container)
+    @containers[container.attributes[:label]] = container
+    true
+  end
+
+  #
+  # Create link relations among containers
+  #
+  def link_containers
+    @containers.each_value do |container|
+      links = container.attributes[:links]
+
+      next if links.nil?
+
+      links.each do |link|
+        dependency_container = @containers[link]
+        container.dependencies << dependency_container
+      end
+    end
+  end
+
+  #
+  # Start a container
+  #
+  # This method accepts an array of labels.
+  # If labels is informed, only those containers with label present in array will be started.
+  # Otherwise, all containers are started
+  #
+  def start(labels = [])
+    call_container_method(:start, labels)
+  end
+
+  #
+  # Stop a container
+  #
+  # This method accepts an array of labels.
+  # If labels is informed, only those containers with label present in array will be stopped.
+  # Otherwise, all containers are stopped
+  #
+  def stop(labels = [])
+    call_container_method(:stop, labels)
+  end
+
+  #
+  # Stop a container
+  #
+  # This method accepts an array of labels.
+  # If labels is informed, only those containers with label present in array will be stopped.
+  # Otherwise, all containers are stopped
+  #
+  def kill(labels  = [])
+    call_container_method(:kill, labels)
+  end
+
+  private
+
+  def call_container_method(method, labels = [])
+    labels = @containers.keys if labels.empty?
+
+    containers = @containers.select { |key, value|
+      labels.include?(key)
+    }
+
+    containers.values.each do |entry|
+      entry.send(method)
+    end
+
+    true
+  end
+end

data/lib/docker-compose/models/compose_container.rb

@@ -0,0 +1,175 @@
+require 'docker'
+require_relative 'compose_port'
+require_relative '../utils/compose_utils'
+
+class ComposeContainer
+  attr_reader :attributes, :dependencies
+
+  def initialize(hash_attributes)
+    @attributes = {
+      label: hash_attributes[:label],
+      image: ComposeUtils.format_image(hash_attributes[:image]),
+      build: hash_attributes[:build],
+      links: hash_attributes[:links],
+      ports: prepare_ports(hash_attributes[:ports]),
+      volumes: hash_attributes[:volumes],
+      command: ComposeUtils.format_command(hash_attributes[:command]),
+      environment: hash_attributes[:environment]
+    }.reject{ |key, value| value.nil? }
+
+    # Docker client variables
+    @container = nil
+    @dependencies = []
+  end
+
+  private
+
+  #
+  # Download or build an image
+  #
+  def prepare_image
+    has_image_or_build_arg = @attributes.key?(:image) || @attributes.key?(:build)
+
+    raise ArgumentError.new('No Image or Build command provided') unless has_image_or_build_arg
+
+    # Build or pull image
+    if @attributes.key?(:image)
+      if image_exists
+        Docker::Image.get(@attributes[:image])
+      else
+        Docker::Image.create('fromImage' => @attributes[:image])
+      end
+    elsif @attributes.key?(:build)
+      Docker::Image.build_from_dir(@attributes[:build])
+    end
+  end
+
+  #
+  # Start a new container with parameters informed in object construction
+  # (TODO: start container from a Dockerfile)
+  #
+  def prepare_container
+    exposed_ports = {}
+    port_bindings = {}
+    links = []
+
+    # Build expose and port binding parameters
+    if !@attributes[:ports].nil?
+      @attributes[:ports].each do |port|
+        exposed_ports["#{port.container_port}/tcp"] = {}
+        port_bindings["#{port.container_port}/tcp"] = [{
+          "HostIp" => port.host_ip || '',
+          "HostPort" => port.host_port || ''
+        }]
+      end
+    end
+
+    # Build link parameters
+    @dependencies.each do |dependency|
+      links << "#{dependency.stats['Id']}:#{dependency.attributes[:label]}"
+    end
+
+    container_config = {
+      Image: @attributes[:image],
+      Cmd: @attributes[:command],
+      Env: @attributes[:environment],
+      Volumes: @attributes[:volumes],
+      ExposedPorts: exposed_ports,
+      HostConfig: {
+        Links: links,
+        PortBindings: port_bindings
+      }
+    }
+
+    @container = Docker::Container.create(container_config)
+  end
+
+  #
+  # Process each port entry in docker compose file and
+  # create structure recognized by docker client
+  #
+  def prepare_ports(port_entries)
+    ports = []
+
+    if port_entries.nil?
+      return nil
+    end
+
+    port_entries.each do |port_entry|
+      ports.push(ComposeUtils.format_port(port_entry))
+    end
+
+    ports
+  end
+
+  #
+  # Check if a given image already exists in host
+  #
+  def image_exists
+    Docker::Image.exist?(@attributes[:image])
+  end
+
+  public
+
+  #
+  # Start the container and its dependencies
+  #
+  def start
+    # Start dependencies
+    @dependencies.each do |dependency|
+      dependency.start unless dependency.running?
+    end
+
+    # Create a container object
+    if @container.nil?
+      prepare_image
+      prepare_container
+    end
+
+    @container.start unless @container.nil?
+  end
+
+  #
+  # Stop the container
+  #
+  def stop
+    @container.kill unless @container.nil?
+  end
+
+  #
+  # Kill the container
+  #
+  def kill
+    @container.kill unless @container.nil?
+  end
+
+  #
+  # Delete the container
+  #
+  def delete
+    @container.delete(:force => true) unless @container.nil?
+    @container = nil
+  end
+
+  #
+  # Add a dependency to this container
+  # (i.e. a container that must be started before this one)
+  #
+  def add_dependency(dependency)
+    @dependencies << dependency
+  end
+
+  #
+  # Return container statistics
+  #
+  def stats
+    @container.json
+  end
+
+  #
+  # Check if a container is already running or not
+  #
+  def running?
+    @container.nil? ? false : self.stats['State']['Running']
+  end
+end

data/lib/docker-compose/models/compose_port.rb

@@ -0,0 +1,9 @@
+class ComposePort
+  attr_reader :container_port, :host_ip, :host_port
+
+  def initialize(container_port, host_port = nil, host_ip = nil)
+    @container_port = container_port
+    @host_ip = host_ip
+    @host_port = host_port
+  end
+end

data/lib/docker-compose/utils/compose_utils.rb

@@ -0,0 +1,60 @@
+module ComposeUtils
+  #
+  # Format a given docker image in a complete structure (base image + tag)
+  #
+  def self.format_image(image)
+    base_image = nil
+    tag = nil
+
+    if image.nil?
+      return nil
+    end
+
+    if image.index(':').nil?
+      base_image = image
+      tag = 'latest'
+    else
+      image_split = image.split(':')
+      base_image = image_split[0]
+      tag = image_split[1]
+    end
+
+    "#{base_image}:#{tag}"
+  end
+
+  #
+  # Transform docker command from string to an array of commands
+  #
+  def self.format_command(command)
+    command.nil? ? nil : command.split(' ')
+  end
+
+  #
+  # Read a port specification in string format
+  # and create a compose port structure
+  #
+  def self.format_port(port_entry)
+    compose_port = nil
+    container_port = nil
+    host_port = nil
+    host_ip = nil
+
+    port_parts = port_entry.split(':')
+
+    case port_parts.length
+      # [container port]
+      when 1
+        compose_port = ComposePort.new(port_parts[0])
+
+      # [host port]:[container port]
+      when 2
+        compose_port = ComposePort.new(port_parts[1], port_parts[0])
+
+      # [host ip]:[host port]:[container port]
+      when 3
+        compose_port = ComposePort.new(port_parts[2], port_parts[1], port_parts[0])
+    end
+
+    compose_port
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+module DockerCompose
+  def self.version
+    "1.0.0"
+  end
+end

data/spec/docker-compose/docker_compose_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe DockerCompose do
+  before(:all) do
+    @compose = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/sample1.yaml'))
+  end
+
+  it 'should be able to access gem version' do
+    expect(DockerCompose.version).to_not be_nil
+  end
+
+  it 'should be able to access Docker client' do
+    expect(DockerCompose.docker_client).to_not be_nil
+  end
+
+  it 'should read a YAML file correctly' do
+    expect(@compose.containers.length).to eq(2)
+  end
+
+  context 'All containers' do
+    it 'should start/stop all containers' do
+      # Start containers to test Stop
+      @compose.start
+      @compose.containers.values.each do |container|
+        expect(container.running?).to be true
+      end
+
+      # Stop containers
+      @compose.stop
+      @compose.containers.values.each do |container|
+        expect(container.running?).to be false
+      end
+    end
+
+    it 'should start/kill all containers' do
+      # Start containers to test Kill
+      @compose.start
+      @compose.containers.values.each do |container|
+        expect(container.running?).to be true
+      end
+
+      # Kill containers
+      @compose.kill
+      @compose.containers.values.each do |container|
+        expect(container.running?).to be false
+      end
+    end
+  end
+
+  context 'Single container' do
+    context 'Without dependencies' do
+      it 'should start/stop a single container' do
+        ubuntu = @compose.containers.values.first.attributes[:label]
+        redis  = @compose.containers.values.last.attributes[:label]
+
+        # Should start Redis only, since it hasn't dependencies
+        @compose.start([redis])
+        expect(@compose.containers[ubuntu].running?).to be false
+        expect(@compose.containers[redis].running?).to be true
+
+        # Stop Redis
+        @compose.stop([redis])
+        expect(@compose.containers[ubuntu].running?).to be false
+        expect(@compose.containers[redis].running?).to be false
+      end
+
+      it 'should start/kill a single container' do
+        ubuntu = @compose.containers.values.first.attributes[:label]
+        redis  = @compose.containers.values.last.attributes[:label]
+
+        # Should start Redis only, since it hasn't dependencies
+        @compose.start([redis])
+        expect(@compose.containers[ubuntu].running?).to be false
+        expect(@compose.containers[redis].running?).to be true
+
+        # Stop Redis
+        @compose.kill([redis])
+        expect(@compose.containers[ubuntu].running?).to be false
+        expect(@compose.containers[redis].running?).to be false
+      end
+    end # context 'Without dependencies'
+
+    context 'With dependencies' do
+      it 'should start/stop a single container' do
+        ubuntu = @compose.containers.values.first.attributes[:label]
+        redis  = @compose.containers.values.last.attributes[:label]
+
+        # Should start Ubuntu and Redis, since Ubuntu depends on Redis
+        @compose.start([ubuntu])
+        expect(@compose.containers[ubuntu].running?).to be true
+        expect(@compose.containers[redis].running?).to be true
+
+        # Stop Ubuntu (Redis keeps running)
+        @compose.stop([ubuntu])
+        expect(@compose.containers[ubuntu].running?).to be false
+        expect(@compose.containers[redis].running?).to be true
+
+        # Stop Redis
+        @compose.stop([redis])
+        expect(@compose.containers[redis].running?).to be false
+      end
+
+      it 'should start/kill a single container' do
+        ubuntu = @compose.containers.values.first.attributes[:label]
+        redis  = @compose.containers.values.last.attributes[:label]
+
+        # Should start Ubuntu and Redis, since Ubuntu depends on Redis
+        @compose.start([ubuntu])
+        expect(@compose.containers[ubuntu].running?).to be true
+        expect(@compose.containers[redis].running?).to be true
+
+        # Kill Ubuntu (Redis keeps running)
+        @compose.kill([ubuntu])
+        expect(@compose.containers[ubuntu].running?).to be false
+        expect(@compose.containers[redis].running?).to be true
+
+        # Kill Redis
+        @compose.kill([redis])
+        expect(@compose.containers[redis].running?).to be false
+      end
+    end # context 'with dependencies'
+  end # context 'Single container'
+
+  it 'should assign ports' do
+    ubuntu = @compose.containers.values.first
+
+    # Start container
+    ubuntu.start
+
+    port_bindings = ubuntu.stats['HostConfig']['PortBindings']
+    exposed_ports = ubuntu.stats['Config']['ExposedPorts']
+
+    # Check port bindings
+    expect(port_bindings.length).to eq(3)
+    expect(port_bindings.key?('3000/tcp')).to be true
+    expect(port_bindings.key?('8000/tcp')).to be true
+    expect(port_bindings.key?('8001/tcp')).to be true
+
+    # Check exposed ports
+    expect(exposed_ports.key?('3000/tcp')).to be true
+    expect(exposed_ports.key?('8000/tcp')).to be true
+    expect(exposed_ports.key?('8001/tcp')).to be true
+
+    # Stop container
+    ubuntu.stop
+  end
+
+  it 'should link containers' do
+    ubuntu = @compose.containers.values.first
+
+    # Start container
+    ubuntu.start
+
+    # Ubuntu should be linked to Redis
+    links = ubuntu.stats['HostConfig']['Links']
+    expect(links.length).to eq(1)
+
+    # Stop container
+    ubuntu.stop
+  end
+
+  after(:all) do
+    @compose.containers.values.each do |entry|
+      entry.delete
+    end
+  end
+end

data/spec/docker-compose/fixtures/sample1.yaml

@@ -0,0 +1,16 @@
+ubuntu:
+  image: ubuntu
+  ports:
+    - "3000"
+    - "8000:8000"
+    - "127.0.0.1:8001:8001"
+  expose:
+    - "5000"
+  links:
+    - redis
+  command: /bin/sleep 60
+
+redis:
+  image: redis
+  expose:
+    - "6000"

data/spec/docker-compose/models/compose_container_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe ComposeContainer do
+  context 'Object creation' do
+    it 'should prepare the attributes correctly' do
+      attributes = {
+        image: 'ubuntu:latest',
+        links: ['links:links'],
+        ports: ['3000', '8000:8000', '127.0.0.1:8001:8001'],
+        volumes: {'/tmp' => {}},
+        command: 'ps aux',
+        environment: ['ENVIRONMENT']
+      }
+
+      entry = ComposeContainer.new(attributes)
+
+      expect(entry.attributes[:image]).to eq(attributes[:image])
+      expect(entry.attributes[:links]).to eq(attributes[:links])
+      expect(entry.attributes[:volumes]).to eq(attributes[:volumes])
+      expect(entry.attributes[:command]).to eq(attributes[:command].split(' '))
+      expect(entry.attributes[:environment]).to eq(attributes[:environment])
+
+      # Check ports structure
+      expect(entry.attributes[:ports].length).to eq(attributes[:ports].length)
+
+      # Port 1: '3000'
+      port_entry = entry.attributes[:ports][0]
+      expect(port_entry.container_port).to eq('3000')
+      expect(port_entry.host_ip).to eq(nil)
+      expect(port_entry.host_port).to eq(nil)
+
+      # Port 2: '8000:8000'
+      port_entry = entry.attributes[:ports][1]
+      expect(port_entry.container_port).to eq('8000')
+      expect(port_entry.host_ip).to eq(nil)
+      expect(port_entry.host_port).to eq('8000')
+
+      # Port 3: '127.0.0.1:8001:8001'
+      port_entry = entry.attributes[:ports][2]
+      expect(port_entry.container_port).to eq('8001')
+      expect(port_entry.host_ip).to eq('127.0.0.1')
+      expect(port_entry.host_port).to eq('8001')
+    end
+  end
+
+  context 'Start container' do
+    it 'should start/stop a container' do
+      attributes = {
+        image: 'ubuntu:latest',
+        links: ['links:links'],
+        volumes: {'/tmp' => {}},
+        command: 'ps aux',
+        environment: ['ENVIRONMENT']
+      }
+
+      entry = ComposeContainer.new(attributes)
+
+      #Start container
+      entry.start
+      expect(entry.running?).to be true
+
+      # Stop container
+      entry.stop
+      expect(entry.running?).to be false
+    end
+
+    it 'should not start a container without either image and build commands' do
+      attributes = {
+        links: ['links:links'],
+        volumes: {'/tmp' => {}},
+        command: 'ps aux',
+        environment: ['ENVIRONMENT']
+      }
+
+      entry = ComposeContainer.new(attributes)
+      expect{entry.start}.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/docker-compose/utils/compose_utils_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ComposeUtils do
+  context 'Format image' do
+    it 'should return nil when image is nil' do
+      expect(ComposeUtils.format_image(nil)).to be_nil
+    end
+
+    it 'should assign latest tag when no tag is provided' do
+      expect(ComposeUtils.format_image('ubuntu')).to eq('ubuntu:latest')
+    end
+
+    it 'should assign base image and tag when both are provided' do
+      expect(ComposeUtils.format_image('ubuntu:11')).to eq('ubuntu:11')
+    end
+  end
+
+  context 'Format command' do
+    it 'should return nil when command is nil' do
+      expect(ComposeUtils.format_command(nil)).to be_nil
+    end
+
+    it 'should return original command as array when command has no whitespaces' do
+      expect(ComposeUtils.format_command('top')).to eq(['top'])
+    end
+
+    it 'should split command in array on whitespaces' do
+      expect(ComposeUtils.format_command('ls -lh')).to eq(['ls', '-lh'])
+    end
+  end
+
+  context 'Format port' do
+    it 'should recognize pattern "[container port]"' do
+      compose_port = ComposeUtils.format_port('8080')
+      expect(compose_port.container_port).to eq('8080')
+      expect(compose_port.host_port).to eq(nil)
+      expect(compose_port.host_ip).to eq(nil)
+    end
+
+    it 'should recognize pattern "[host port]:[container port]"' do
+      compose_port = ComposeUtils.format_port('8080:7777')
+      expect(compose_port.container_port).to eq('7777')
+      expect(compose_port.host_port).to eq('8080')
+      expect(compose_port.host_ip).to eq(nil)
+    end
+
+    it 'should recognize pattern "[host ip]:[host port]:[container port]' do
+      compose_port = ComposeUtils.format_port('127.0.0.1:8080:7777')
+      expect(compose_port.container_port).to eq('7777')
+      expect(compose_port.host_port).to eq('8080')
+      expect(compose_port.host_ip).to eq('127.0.0.1')
+    end
+  end
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: docker-compose-api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mauricio S. Klein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.22.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.22.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple ruby client for docker-compose api
+email:
+- mauricio.klein.msk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- docker-compose-api.gemspec
+- lib/docker-compose.rb
+- lib/docker-compose/models/compose.rb
+- lib/docker-compose/models/compose_container.rb
+- lib/docker-compose/models/compose_port.rb
+- lib/docker-compose/utils/compose_utils.rb
+- lib/version.rb
+- spec/docker-compose/docker_compose_spec.rb
+- spec/docker-compose/fixtures/sample1.yaml
+- spec/docker-compose/models/compose_container_spec.rb
+- spec/docker-compose/utils/compose_utils_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/mauricioklein/docker-compose-api
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple ruby client for docker-compose api
+test_files:
+- spec/docker-compose/docker_compose_spec.rb
+- spec/docker-compose/fixtures/sample1.yaml
+- spec/docker-compose/models/compose_container_spec.rb
+- spec/docker-compose/utils/compose_utils_spec.rb
+- spec/spec_helper.rb