hostsfile 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b51455b82fe75732e2b22f6a9222a51abb16b1fa
+  data.tar.gz: 183d81cc05822093b1d3094f3f523da5a98b7a2e
+SHA512:
+  metadata.gz: 58ff7a872890643f04307497a6de91f8929890b67fbd3dca1c3d6f828cce7453b0e73c7f430fdd107af29aeb65269d4a079561f7f3046940901d0d4c4d3c1592
+  data.tar.gz: f307fe72a5555b58e10dc8c77fc1f2e77b68387763a165401830d13b3b653d35856a5d712f7a51110ee4e3ee137029a316fb1653956ed9eef3f05604f06cb4d8

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-gemset
+.ruby-version

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format doc
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hostsfile.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,17 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2013-14 tnarik <tnarik@lecafeautomatique.co.uk>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,29 @@
+# Hostsfile
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hostsfile'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hostsfile
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/tnarik/hostsfile/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/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+# Default :spec task
+RSpec::Core::RakeTask.new(:spec)
+# .rspec is used for options.
+# Different options for 'rake spec' can be configured using the below version.
+#RSpec::Core::RakeTask.new do |task|
+#  task.rspec_opts = ['--color', '--format', 'progress']
+#end
+
+task :default => :spec

data/hostsfile.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hostsfile/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hostsfile"
+  spec.version       = Hostsfile::VERSION
+  spec.authors       = ["tnarik"]
+  spec.email         = ["tnarik@lecafeautomatique.co.uk"]
+  spec.summary       = %q{code from the hostsfile cookbook to allow reusability}
+  spec.description   = %q{code from the hostsfile cookbook to allow reusability}
+  spec.homepage      = ""
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  
+  spec.add_development_dependency "terminal-notifier-guard"
+  # Pre OS X 10.8
+  # spec.add_development_dependency "ruby_gntp"
+end

data/lib/hostsfile/entry.rb

@@ -0,0 +1,175 @@
+# Copyright 2012-2013, Seth Vargo (from customink-webops/hostsfile/libraries/entry.rb)
+# Copyright 2012, CustomInk, LCC
+#
+
+require 'ipaddr'
+
+module Hostsfile
+
+# An object representation of a single line in a hostsfile.
+#
+# @author Seth Vargo <sethvargo@gmail.com>
+class Entry
+  class << self
+    # Creates a new Hostsfile::Entry object by parsing a text line. The
+    # `line` attribute will be in the following format:
+    #
+    #     1.2.3.4 hostname [alias[, alias[, alias]]] [# comment [@priority]]
+    #
+    # @param [String] line
+    #   the line to parse
+    # @return [Entry]
+    #   a new entry object
+    def parse(line)
+      entry, comment = extract_comment(line)
+      comment, priority = extract_priority(comment)
+      entries = extract_entries(entry)
+
+      # Return nil if the line is empty
+      return nil if entries.nil? || entries.empty?
+
+      return self.new(
+        ip_address: entries[0],
+        hostname:   entries[1],
+        aliases:    entries[2..-1],
+        comment:    comment,
+        priority:   priority,
+      )
+    end
+
+    private
+      def extract_comment(line)
+        return nil if presence(line).nil?
+        line.split('#', 2).collect { |part| presence(part) }
+      end
+
+      def extract_priority(comment)
+        return nil if comment.nil?
+
+        if comment.include?('@')
+          comment.split('@', 2).collect { |part| presence(part) }
+        else
+          [comment, nil]
+        end
+      end
+
+      def extract_entries(entry)
+        return nil if entry.nil?
+        entry.split(/\s+/).collect { |entry| presence(entry) }.compact
+      end
+
+      def presence(string)
+        return nil if string.nil?
+        return nil if string.strip.empty?
+        string.strip
+      end
+  end
+
+  # @return [String]
+  attr_accessor :ip_address, :hostname, :aliases, :comment, :priority
+
+  # Creates a new entry from the given options.
+  #
+  # @param [Hash] options
+  #   a list of options to create the entry with
+  # @option options [String] :ip_address
+  #   the IP Address for this entry
+  # @option options [String] :hostname
+  #   the hostname for this entry
+  # @option options [String, Array<String>] :aliases
+  #   a alias or array of aliases for this entry
+  # @option options[String] :comment
+  #   an optional comment for this entry
+  # @option options [Fixnum] :priority
+  #   the relative priority of this entry (compared to others)
+  #
+  # @raise [ArgumentError]
+  #   if neither :ip_address nor :hostname are supplied
+  def initialize(options = {})
+    if options[:ip_address].nil? || options[:hostname].nil?
+      raise ArgumentError, ':ip_address and :hostname are both required options'
+    end
+
+    @ip_address = IPAddr.new(options[:ip_address].to_s)
+    @hostname   = options[:hostname]
+    @aliases    = [options[:aliases]].flatten.compact
+    @comment    = options[:comment]
+    @priority   = options[:priority] || calculated_priority
+  end
+
+  # Set a the new priority for an entry.
+  #
+  # @param [Fixnum] new_priority
+  #   the new priority to set
+  def priority=(new_priority)
+    @calculated_priority = false
+    @priority = new_priority
+  end
+
+  # The line representation of this entry.
+  #
+  # @return [String]
+  #   the string representation of this entry
+  def to_line
+    hosts = [hostname, aliases].flatten.join(' ')
+
+    comments = "# #{comment.to_s}".strip
+    comments << " @#{priority}" unless priority.nil? || @calculated_priority
+    comments = comments.strip
+    comments = nil if comments == '#'
+
+    [ip_address, hosts, comments].compact.join("\t").strip
+  end
+
+  # The string representation of this Entry
+  #
+  # @return [String]
+  #   the string representation of this entry
+  def to_s
+    "#<#{self.class.to_s} " + [
+      "ip_address: '#{ip_address}'",
+      "hostname: '#{hostname}'",
+    ].join(', ') + '>'
+  end
+
+  # The object representation of this Entry
+  #
+  # @return [String]
+  #   the object representation of this entry
+  def inspect
+    "#<#{self.class.to_s} " + [
+      "ip_address: '#{ip_address}'",
+      "hostname: '#{hostname}'",
+      "aliases: #{aliases.inspect}",
+      "comment: '#{comment}'",
+      "priority: #{priority}",
+      "calculated_priority?: #{@calculated_priority}",
+    ].join(', ') + '>'
+  end
+
+  # Returns true if priority is calculated
+  #
+  # @return [Boolean]
+  #   true if priority is calculated and false otherwise
+  def calculated_priority?
+    @calculated_priority
+  end
+
+  private
+
+    # Calculates the relative priority of this entry.
+    #
+    # @return [Fixnum]
+    #   the relative priority of this item
+    def calculated_priority
+      @calculated_priority = true
+
+      return 81 if ip_address == IPAddr.new('127.0.0.1')
+      return 80 if IPAddr.new('127.0.0.0/8').include?(ip_address) # local
+      return 60 if ip_address.ipv4? # ipv4
+      return 20 if ip_address.ipv6? # ipv6
+      return 00
+    end
+end
+
+end

data/lib/hostsfile/manipulator.rb

@@ -0,0 +1,259 @@
+# Copyright 2013-14, Tnarik Innael
+# Copyright 2012-2013, Seth Vargo (from customink-webops/hostsfile/libraries/manipulator.rb)
+# Copyright 2012, CustomInk, LCC
+#
+
+require 'digest/sha2'
+
+module Hostsfile
+
+class Manipulator
+  attr_reader :entries
+
+  # Create a new Manipulator object (aka an /etc/hosts manipulator). If a
+  # hostsfile is not found, a Exception is risen, causing
+  # the process to terminate on the node and the converge will fail.
+  #
+  # @param [Chef::node] node
+  #   the current Chef node
+  # @return [Manipulator]
+  #   a class designed to manipulate the node's /etc/hosts file
+  def initialize(path = nil, family = nil, system_directory = nil)
+    # Fail if no hostsfile is found
+    unless ::File.exists?(hostsfile_path)
+      raise "No hostsfile exists at '#{hostsfile_path}'!"
+    end
+
+    @entries = []
+    collect_and_flatten(::File.readlines(hostsfile_path))
+  end
+
+  # Return a list of all IP Addresses for this hostsfile.
+  #
+  # @return [Array<IPAddr>]
+  #   the list of IP Addresses
+  def ip_addresses
+    @entries.collect do |entry|
+      entry.ip_address
+    end.compact || []
+  end
+
+  # Add a new record to the hostsfile.
+  #
+  # @param [Hash] options
+  #   a list of options to create the entry with
+  # @option options [String] :ip_address
+  #   the IP Address for this entry
+  # @option options [String] :hostname
+  #   the hostname for this entry
+  # @option options [String, Array<String>] :aliases
+  #   a alias or array of aliases for this entry
+  # @option options[String] :comment
+  #   an optional comment for this entry
+  # @option options [Fixnum] :priority
+  #   the relative priority of this entry (compared to others)
+  def add(options = {})
+    entry = ::Hostsfile::Entry.new(
+      ip_address: options[:ip_address],
+      hostname:   options[:hostname],
+      aliases:    options[:aliases],
+      comment:    options[:comment],
+      priority:   options[:priority],
+    )
+
+    @entries << entry
+    remove_existing_hostnames(entry) if options[:unique]
+  end
+
+  # Update an existing entry. This method will do nothing if the entry
+  # does not exist.
+  #
+  # @param (see #add)
+  def update(options = {})
+    if entry = find_entry_by_ip_address(options[:ip_address])
+      entry.hostname  = options[:hostname]
+      entry.aliases   = options[:aliases]
+      entry.comment   = options[:comment]
+      entry.priority  = options[:priority]
+
+      remove_existing_hostnames(entry) if options[:unique]
+    end
+  end
+
+  # Append content to an existing entry. This method will add a new entry
+  # if one does not already exist.
+  #
+  # @param (see #add)
+  def append(options = {})
+    if entry = find_entry_by_ip_address(options[:ip_address])
+      hosts          = normalize(entry.hostname, entry.aliases, options[:hostname], options[:aliases])
+      entry.hostname = hosts.shift
+      entry.aliases  = hosts
+
+      unless entry.comment && options[:comment] && entry.comment.include?(options[:comment])
+        entry.comment = normalize(entry.comment, options[:comment]).join(', ')
+      end
+
+      remove_existing_hostnames(entry) if options[:unique]
+    else
+      add(options)
+    end
+  end
+
+  # Remove an entry by it's IP Address
+  #
+  # @param [String] ip_address
+  #   the IP Address of the entry to remove
+  def remove(ip_address)
+    if entry = find_entry_by_ip_address(ip_address)
+      @entries.delete(entry)
+    end
+  end
+
+  # Save the new hostsfile to the target machine. This method will only write the
+  # hostsfile if the current version has changed. In other words, it is convergent.
+  def save
+    entries = []
+    entries << '#'
+    entries << '# This file is managed by Chef, using the hostsfile cookbook.'
+    entries << '# Editing this file by hand is highly discouraged!'
+    entries << '#'
+    entries << '# Comments containing an @ sign should not be modified or else'
+    entries << '# hostsfile will be unable to guarantee relative priority in'
+    entries << '# future Chef runs!'
+    entries << '#'
+    entries << ''
+    entries += unique_entries.map(&:to_line)
+    entries << ''
+
+    contents = entries.join("\n")
+    contents_sha = Digest::SHA512.hexdigest(contents)
+
+    # Only write out the file if the contents have changed...
+    if contents_sha != current_sha
+      ::File.open(hostsfile_path, 'w') do |f|
+        f.write(contents)
+      end
+    end
+  end
+
+  # Find an entry by the given IP Address.
+  #
+  # @param [String] ip_address
+  #   the IP Address of the entry to find
+  # @return [Entry, nil]
+  #   the corresponding entry object, or nil if it does not exist
+  def find_entry_by_ip_address(ip_address)
+    @entries.find do |entry|
+      !entry.ip_address.nil? && entry.ip_address == ip_address
+    end
+  end
+
+  # Determine if the current hostsfile contains the given resource. This
+  # is really just a proxy to {find_resource_by_ip_address} /
+  #
+  # @param [Chef::Resource] resource
+  #
+  # @return [Boolean]
+  def contains?(resource)
+    !!find_entry_by_ip_address(resource.ip_address)
+  end
+
+  private
+    # The path to the current hostsfile.
+    #
+    # @return [String]
+    #   the full path to the hostsfile, depending on the operating system
+    #   can also be overriden in the attributes
+    def hostsfile_path (path = nil, family = nil, system_directory = nil)
+      return @hostsfile_path if @hostsfile_path
+      @hostsfile_path = path || case family
+                                  when 'windows'
+                                    "#{system_directory}\\drivers\\etc\\hosts"
+                                  else
+                                    '/etc/hosts'
+                                end
+    end
+
+    # The current sha of the system hostsfile.
+    #
+    # @return [String]
+    #   the sha of the current hostsfile
+    def current_sha
+      @current_sha ||= Digest::SHA512.hexdigest(File.read(hostsfile_path))
+    end
+
+    # Normalize the given list of elements into a single array with no nil
+    # values and no duplicate values.
+    #
+    # @param [Object] things
+    #
+    # @return [Array]
+    #   a normalized array of things
+    def normalize(*things)
+      things.flatten.compact.uniq
+    end
+
+    # This is a crazy way of ensuring unique objects in an array using a Hash.
+    #
+    # @return [Array]
+    #   the sorted list of entires that are unique
+    def unique_entries
+      entries = Hash[*@entries.map { |entry| [entry.ip_address, entry] }.flatten].values
+      entries.sort_by { |e| [-e.priority.to_i, e.hostname.to_s] }
+    end
+
+    # Takes /etc/hosts file contents and builds a flattened entries
+    # array so that each IP address has only one line and multiple hostnames
+    # are flattened into a list of aliases.
+    #
+    # @param [Array] contents
+    #   Array of lines from /etc/hosts file
+    def collect_and_flatten(contents)
+      contents.each do |line|
+        entry = ::Hostsfile::Entry.parse(line)
+        next if entry.nil?
+
+        append(
+          ip_address: entry.ip_address,
+          hostname:   entry.hostname,
+          aliases:    entry.aliases,
+          comment:    entry.comment,
+          priority:   !entry.calculated_priority? && entry.priority,
+        )
+      end
+    end
+
+    # Removes duplicate hostnames in other files ensuring they are unique
+    #
+    # @param [Entry] entry
+    #   the entry to keep the hostname and aliases from
+    #
+    # @return [nil]
+    def remove_existing_hostnames(entry)
+      @entries.delete(entry)
+      changed_hostnames = [entry.hostname, entry.aliases].flatten.uniq
+
+      @entries = @entries.collect do |entry|
+        entry.hostname = nil if changed_hostnames.include?(entry.hostname)
+        entry.aliases  = entry.aliases - changed_hostnames
+
+        if entry.hostname.nil?
+          if entry.aliases.empty?
+            nil
+          else
+            entry.hostname = entry.aliases.shift
+            entry
+          end
+        else
+          entry
+        end
+      end.compact
+
+      @entries << entry
+
+      nil
+    end
+end
+
+end

data/lib/hostsfile/version.rb

@@ -0,0 +1,5 @@
+# Copyright 2013-14, Tnarik Innael
+
+module Hostsfile
+  VERSION = "0.0.1"
+end

data/lib/hostsfile.rb

@@ -0,0 +1,6 @@
+require "hostsfile/version"
+require "hostsfile/manipulator"
+require "hostsfile/entry"
+
+module Hostsfile
+end

data/spec/hostsfile_spec.rb

@@ -0,0 +1,75 @@
+describe Hostsfile do
+  describe "::VERSION" do
+    it "exists" do
+      expect(Hostsfile::VERSION).not_to be_empty
+    end
+  end
+
+  describe "::Entry" do
+    it "exists" do
+      expect(Hostsfile::Entry::respond_to? :new).to eq(true)
+    end
+
+    it "#to_line" do
+      h = Hostsfile::Entry.new ip_address: "0.0.0.0", hostname: "test"
+      expect(h.respond_to? :to_line).to eq(true)
+    end
+
+    it "#to_line_response" do
+      h = Hostsfile::Entry.new ip_address: "0.0.0.0", hostname: "test"
+      expect(h.to_line).to eq("0.0.0.0\ttest")
+    end
+
+    it "#to_s" do
+      h = Hostsfile::Entry.new ip_address: "0.0.0.0", hostname: "test"
+      expect(h.respond_to? :to_line).to eq(true)
+    end
+  end
+
+  describe "::Manipulator" do
+    it "exists" do
+      expect(Hostsfile::Manipulator::respond_to? :new).to eq(true)
+    end
+
+    #it "#append" do
+    #  h = Hostsfile::Manipulator.new
+    #  expect(h.respond_to? :append).to eq(true)
+    #end
+  end
+end
+
+## Manipulator
+#  def initialize(path = nil, family = nil, system_directory = nil)
+#  def ip_addresses
+#  def add(options = {})
+#  def update(options = {})
+#  def append(options = {})
+#  def remove(ip_address)
+#  def save
+#  def find_entry_by_ip_address(ip_address)
+#  def contains?(resource)
+#  private
+#    def hostsfile_path (path = nil, family = nil, system_directory = nil)
+#    def current_sha
+#    def normalize(*things)
+#    def unique_entries
+#    def collect_and_flatten(contents)
+#    def remove_existing_hostnames(entry)
+
+
+## Entry
+#    def parse(line)
+#    private
+#      def extract_comment(line)
+#      def extract_priority(comment)
+#      def extract_entries(entry)
+#      def presence(string)
+#
+#  def initialize(options = {})
+#  def priority=(new_priority)
+#  def to_line
+#  def to_s
+#  def inspect
+#  def calculated_priority?
+#  private
+#    def calculated_priority

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'hostsfile'

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: hostsfile
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- tnarik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier-guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: code from the hostsfile cookbook to allow reusability
+email:
+- tnarik@lecafeautomatique.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hostsfile.gemspec
+- lib/hostsfile.rb
+- lib/hostsfile/entry.rb
+- lib/hostsfile/manipulator.rb
+- lib/hostsfile/version.rb
+- spec/hostsfile_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- Apache-2.0
+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.2.2
+signing_key: 
+specification_version: 4
+summary: code from the hostsfile cookbook to allow reusability
+test_files:
+- spec/hostsfile_spec.rb
+- spec/spec_helper.rb