hostsfile 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b51455b82fe75732e2b22f6a9222a51abb16b1fa
-  data.tar.gz: 183d81cc05822093b1d3094f3f523da5a98b7a2e
+  metadata.gz: 0df9590599c111715cca1d3e873ccf494a58b6ba
+  data.tar.gz: ce025bcf57210c92e589356129cc775dbdcb55dd
 SHA512:
-  metadata.gz: 58ff7a872890643f04307497a6de91f8929890b67fbd3dca1c3d6f828cce7453b0e73c7f430fdd107af29aeb65269d4a079561f7f3046940901d0d4c4d3c1592
-  data.tar.gz: f307fe72a5555b58e10dc8c77fc1f2e77b68387763a165401830d13b3b653d35856a5d712f7a51110ee4e3ee137029a316fb1653956ed9eef3f05604f06cb4d8
+  metadata.gz: 8d3bbefaae49d7797e16e1b9361e301447c0b1e591d0fcc87e387acc131b26dc64fc17377088899adc3d22f95b7aa352f7d3bd45224fc0521588be78883fb4c0
+  data.tar.gz: 4c12713032af45faffd8f0cdb3c5940aee31e053938830cced802856455fef8b22bddc6f13f155c11d784d04beef3c5f49bdf82d622543d7fdb2a652b2c22127

data/Guardfile

@@ -11,7 +11,7 @@
 #  * '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(%r{^lib/([^/]+).*\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
   watch('spec/spec_helper.rb')  { "spec" }
 end
 

data/README.md

@@ -1,24 +1,22 @@
 # Hostsfile
 
-TODO: Write a gem description
+[![Build Status](http://img.shields.io/travis/tnarik/hostsfile.svg)](https://travis-ci.org/tnarik/hostsfile)
+[![Code Climate](http://img.shields.io/codeclimate/github/tnarik/hostsfile.svg)](https://codeclimate.com/github/tnarik/hostsfile)
+[![Coveralls](http://img.shields.io/coveralls/tnarik/hostsfile.svg)](https://coveralls.io/r/tnarik/hostsfile)
+[![RubyGems](http://img.shields.io/gem/v/hostsfile.svg)](http://rubygems.org/gems/hostsfile)
+[![Gemnasium](http://img.shields.io/gemnasium/tnarik/hostsfile.svg)](https://gemnasium.com/tnarik/hostsfile)
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install via Rubygems or Gemfile
 
-    gem 'hostsfile'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install hostsfile
+```zsh
+$ gem install hostsfile
+```
 
 ## Usage
 
-TODO: Write usage instructions here
+This gem has been extracted from [customink-webops/hostsfile code](https://github.com/customink-webops/hostsfile), to decouple it from Chef, so that it can be used independently.
 
 ## Contributing
 
@@ -26,4 +24,10 @@ TODO: Write usage instructions here
 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
+5. Create a new Pull Request
+
+## Authors
+
+- Tnarik Innael (@tnarik) : gem packaging, tests
+- Seth Vargo (@sethvargo) : original code as part of [the 'hostsfile' cookbook](https://github.com/customink-webops/hostsfile)
+- CustomInk, LCC : original code as part of [the 'hostsfile' cookbook](https://github.com/customink-webops/hostsfile)

data/hostsfile.gemspec

@@ -6,11 +6,11 @@ require 'hostsfile/version'
 Gem::Specification.new do |spec|
   spec.name          = "hostsfile"
   spec.version       = Hostsfile::VERSION
-  spec.authors       = ["tnarik"]
+  spec.authors       = ["Tnarik Innael"]
   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.homepage      = "https://github.com/tnarik/hostsfile"
   spec.license       = "Apache-2.0"
 
   spec.files         = `git ls-files`.split($/)
@@ -18,14 +18,22 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  # development dependencies  
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
 
+  # development dependencies (testing)
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "fakefs"
+
+  # development dependencies (coverage)
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-console'
   
+  # development dependencies (notifier), controlled by .guard.rb
   spec.add_development_dependency "terminal-notifier-guard"
-  # Pre OS X 10.8
-  # spec.add_development_dependency "ruby_gntp"
+  spec.add_development_dependency "ruby_gntp" # Pre OS X 10.8
 end

data/lib/hostsfile/entry.rb

@@ -1,3 +1,6 @@
+# Copyright 2013-14, Tnarik Innael
+#
+# Heavily based on:
 # Copyright 2012-2013, Seth Vargo (from customink-webops/hostsfile/libraries/entry.rb)
 # Copyright 2012, CustomInk, LCC
 #
@@ -28,6 +31,14 @@ class Entry
       # Return nil if the line is empty
       return nil if entries.nil? || entries.empty?
 
+      # If the hostsfile has broken content:
+      #if entries[0].nil?
+      #  raise ArgumentError, "Hostsfile has a line without IP address: #{line}"
+      #end
+      if entries[1].nil?
+        raise ArgumentError, "Hostsfile has a line without hostname: #{line}"
+      end
+
       return self.new(
         ip_address: entries[0],
         hostname:   entries[1],
@@ -38,31 +49,31 @@ class Entry
     end
 
     private
-      def extract_comment(line)
-        return nil if presence(line).nil?
-        line.split('#', 2).collect { |part| presence(part) }
-      end
+    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?
+    def extract_priority(comment)
+      return nil if comment.nil?
 
-        if comment.include?('@')
-          comment.split('@', 2).collect { |part| presence(part) }
-        else
-          [comment, nil]
-        end
+      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 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
+    def presence(string)
+      return nil if string.nil?
+      return nil if string.strip.empty?
+      string.strip
+    end
   end
 
   # @return [String]
@@ -90,7 +101,7 @@ class Entry
       raise ArgumentError, ':ip_address and :hostname are both required options'
     end
 
-    @ip_address = IPAddr.new(options[:ip_address].to_s)
+    @ip_address = IPAddr.new(remove_ip_scope(options[:ip_address]))
     @hostname   = options[:hostname]
     @aliases    = [options[:aliases]].flatten.compact
     @comment    = options[:comment]
@@ -121,32 +132,6 @@ class Entry
     [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]
@@ -156,20 +141,32 @@ class Entry
   end
 
   private
+  # Calculates the relative priority of this entry.
+  #
+  # @return [Fixnum]
+  #   the relative priority of this item
+  def calculated_priority
+    @calculated_priority = true
 
-    # 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
+    priority ||= 81 if ip_address == IPAddr.new('127.0.0.1')
+    priority ||= 80 if IPAddr.new('127.0.0.0/8').include?(ip_address) # local
+    priority ||= 60 if ip_address.ipv4? # ipv4
+    priority ||= 20 if ip_address.ipv6? # ipv6
+
+    return priority || 00
+  end
+
+  # Removes the scopes pieces of the address, because of the below reasons.
+  #
+  # @see https://bugs.ruby-lang.org/issues/8464
+  # @see https://github.com/customink-webops/hostsfile/issues/51
+  #
+  # @return [String, nil]
+  #
+  def remove_ip_scope(address)
+    return nil if address.nil?
+    address.to_s.sub(/%.*/, '')
+  end
 end
 
 end

data/lib/hostsfile/manipulator.rb

@@ -1,4 +1,6 @@
 # Copyright 2013-14, Tnarik Innael
+#
+# Heavily based on:
 # Copyright 2012-2013, Seth Vargo (from customink-webops/hostsfile/libraries/manipulator.rb)
 # Copyright 2012, CustomInk, LCC
 #
@@ -9,18 +11,21 @@ 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.
+  # hostsfile is not found, a Exception is risen.
+  # Parameters are optional (see #hostsfile_path)
   #
-  # @param [Chef::node] node
-  #   the current Chef node
+  # @param [String] path
+  #   the file path for the host file
+  # @param [String] family
+  #   the OS family ('windows' or anything else for POSIX support)
+  # @param [String] system_directory
+  #   System directory for the 'windows' family (like C:\\Windows\\system32)
   # @return [Manipulator]
-  #   a class designed to manipulate the node's /etc/hosts file
+  #   a class designed to manipulate the /etc/hosts file
   def initialize(path = nil, family = nil, system_directory = nil)
     # Fail if no hostsfile is found
-    unless ::File.exists?(hostsfile_path)
+    unless ::File.exists?(hostsfile_path(path, family, system_directory))
       raise "No hostsfile exists at '#{hostsfile_path}'!"
     end
 
@@ -113,28 +118,19 @@ class Manipulator
   # 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
+    ::File.open(hostsfile_path, 'w') do |f|
+      f.write(new_content)
+    end if content_changed?
+  end
+
+  # Determine if the content of the hostfile has changed by comparing sha
+  # values of existing file and new content
+  #
+  # @return [Boolean]
+  def content_changed?
+    new_sha = Digest::SHA512.hexdigest(new_content)
+    new_sha != current_sha
   end
 
   # Find an entry by the given IP Address.
@@ -152,108 +148,144 @@ class Manipulator
   # 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
-  #
+  # @param [String] ip_address
+  #   the IP Address of the entry to check
   # @return [Boolean]
-  def contains?(resource)
-    !!find_entry_by_ip_address(resource.ip_address)
+  def contains?(ip_address)
+    !!find_entry_by_ip_address(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 path to the current hostsfile.
+  # If not path is provided, a default is guessed based on 'family' and 'system_directory'
+  # If path is provided, it takes priority
+  #
+  # @param [String] path
+  #   the file path for the host file
+  # @param [String] family
+  #   the OS family ('windows' or anything else for POSIX support)
+  # @param [String] system_directory
+  #   System directory for the 'windows' family (default C:\\Windows\\system32)
+  # @return [String]
+  #   the full path to the hostsfile, depending on the operating system
+  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 ||= File.join('C:','Windows','system32')
+                                  File.join("#{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
+  # The header of the new hostsfile
+  #
+  # @return [Array]
+  #   an array of header comments
+  def hostsfile_header
+    lines = []
+    lines << '#'
+    lines << '# This file is managed by the hostsfile gem.'
+    lines << '# Editing this file by hand is highly discouraged!'
+    lines << '#'
+    lines << '# Comments containing an @ sign should not be modified or else'
+    lines << '# hostsfile will be unable to guarantee relative priority in'
+    lines << '# future runs!'
+    lines << '#'
+    lines << ''
+  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
+  # The content that will be written to the hostfile
+  #
+  # @return [String]
+  #   the full contents of the hostfile to be written
+  def new_content
+    lines = hostsfile_header
+    lines += unique_entries.map(&:to_line)
+    lines << ''
+    lines.join("\n")
+  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
+  # 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
 
-    # 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?
+  # 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
 
-        append(
-          ip_address: entry.ip_address,
-          hostname:   entry.hostname,
-          aliases:    entry.aliases,
-          comment:    entry.comment,
-          priority:   !entry.calculated_priority? && entry.priority,
-        )
-      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
+  # 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
+    @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
+      if entry.hostname.nil?
+        if entry.aliases.empty?
+          nil
         else
+          entry.hostname = entry.aliases.shift
           entry
         end
-      end.compact
+      else
+        entry
+      end
+    end.compact
 
-      @entries << entry
+    @entries << entry
 
-      nil
-    end
+    nil
+  end
 end
 
 end

data/lib/hostsfile/version.rb

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

data/spec/entry_spec.rb

@@ -0,0 +1,43 @@
+require 'fakefs/spec_helpers'
+
+describe Hostsfile do
+  describe "::Entry" do
+    let(:entry) { Hostsfile::Entry.new ip_address: "0.0.0.0", hostname: "test" }
+
+    context "#parse" do
+      it "raises a fatal error if the hostname is missing (considers the first field the IP" do
+        expect { Hostsfile::Entry.parse "0.0.0.0"}.to raise_error(ArgumentError, /Hostsfile has a line without hostname/)
+        expect { Hostsfile::Entry.parse "       hostname"}.to raise_error(ArgumentError, /Hostsfile has a line without hostname/)
+        expect { Hostsfile::Entry.parse "       \thostname"}.to raise_error(ArgumentError, /Hostsfile has a line without hostname/)
+        expect { Hostsfile::Entry.parse "\thostname"}.to raise_error(ArgumentError, /Hostsfile has a line without hostname/)
+      end
+    end
+
+    context "#to_line" do
+      it "exists" do
+        expect(entry.respond_to? :to_line).to eq(true)
+      end
+
+      it "generates a proper line" do
+        expect(entry.to_line).to eq("0.0.0.0\ttest")
+      end
+    end
+  end
+end
+
+## 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/fixtures/sample_hosts

@@ -0,0 +1,10 @@
+##
+# Host Database
+#
+# localhost is used to configure the loopback interface
+# when the system is booting.  Do not change this entry.
+##
+127.0.0.1 localhost
+192.0.2.1 awesome.example.com
+192.0.2.2 fine.example.com refined.example.com
+2001:db8::1 ipv6.example.com

data/spec/hostsfile_spec.rb

@@ -1,75 +1,9 @@
+require 'fakefs/spec_helpers'
+
 describe Hostsfile do
   describe "::VERSION" do
-    it "exists" do
+    it "is defined" 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/manipulator_spec.rb

@@ -0,0 +1,202 @@
+require 'fakefs/spec_helpers'
+
+describe Hostsfile do
+  describe "::Manipulator" do 
+    include FakeFS::SpecHelpers
+
+    before(:each) do
+      fixture_to_fakefs("sample_hosts", "/etc/hosts")
+      fixture_to_fakefs("sample_hosts", "/windows/drivers/etc/hosts")
+    end
+
+    let(:manipulator) { Hostsfile::Manipulator.new }
+
+    context "#initialize" do
+      it "raises a fatal error if the hostfile does not exist" do
+        expect { Hostsfile::Manipulator.new "/etc/hosts_does_not_exist"}.to raise_error(RuntimeError)
+      end
+
+      it "reads the default /etc/hosts file if none is specified" do
+        expect { Hostsfile::Manipulator.new }.to_not raise_error
+        expect(Hostsfile::Manipulator.new.ip_addresses.size).to be(4)
+      end
+
+      it "reads the default drivers/etc/hosts file for windows with a system directory" do
+        expect { Hostsfile::Manipulator.new nil, 'windows', '/windows'}.to_not raise_error
+        expect(Hostsfile::Manipulator.new(nil, 'windows', '/windows').ip_addresses.size).to be(4)
+      end
+    end
+
+    context "#ip_addresses" do
+      it "reads ip addresses correctly" do
+        expect(manipulator.ip_addresses.size).to be(4)
+      end
+    end
+
+    context '#find_entry_by_ip_address' do
+      it 'finds the associated entry' do
+        expect( manipulator.find_entry_by_ip_address('127.0.0.1') ).not_to be_nil
+      end
+  
+      it 'returns nil if the entry does not exist' do
+        expect( manipulator.find_entry_by_ip_address('192.0.2.0') ).to be_nil
+      end
+    end
+
+    context '#contains?' do
+      it 'detects an existing entry' do
+        expect( manipulator.contains?('127.0.0.1') ).to be_truthy
+      end
+  
+      it 'detects the non existing entry' do
+        expect( manipulator.contains?('192.0.2.0') ).to be_falsey
+      end
+    end
+
+    context "#add" do
+      let(:options) { { ip_address: '192.0.2.0', hostname: 'example.com', aliases: nil, comment: 'Some comment', priority: 5 } }
+      let(:minimal_options) { { ip_address: '192.0.2.0', hostname: 'example.com' } }
+
+      it "requires at least IP Address and Hostname" do
+        expect { manipulator.add(ip_address: options[:ip_address]) }.to raise_error(ArgumentError)
+        expect { manipulator.add(hostname: options[:hostname]) }.to raise_error(ArgumentError)
+        expect { manipulator.add(aliases: options[:aliases]) }.to raise_error(ArgumentError)
+        expect { manipulator.add(comment: options[:comment]) }.to raise_error(ArgumentError)
+
+        expect { manipulator.add(options.reject {|k| k == :ip_address}) }.to raise_error(ArgumentError)
+        expect { manipulator.add(options.reject {|k| k == :hostname}) }.to raise_error(ArgumentError)
+
+        expect { manipulator.add(minimal_options) }.to change{manipulator.ip_addresses.size}.from(4).to(5)
+      end
+
+      it "add entries in memory until save" do # Includes debugging
+        expect { manipulator.add(options) }.to change{manipulator.ip_addresses.size}.from(4).to(5)
+        refreshed_manipulator = Hostsfile::Manipulator.new
+        expect(refreshed_manipulator.ip_addresses.size).to be(4)
+        manipulator.save
+        refreshed_manipulator = Hostsfile::Manipulator.new
+        expect(refreshed_manipulator.ip_addresses.size).to be(5)
+        puts File.read("/etc/hosts")
+      end
+    end
+
+    context "#update" do
+      let(:options) { { ip_address: '127.0.0.1', hostname: 'new.example.com' } }
+      let(:not_existing_options) { { ip_address: '192.0.2.0', hostname: 'new.example.com' } }
+      context "when the entry exists" do
+        it "does not add a new entry" do
+          expect { manipulator.update(options) }.not_to change{manipulator.ip_addresses.size}
+        end
+
+        it "updates the entry" do  # Includes debugging
+          p manipulator.find_entry_by_ip_address(options[:ip_address])
+          expect { manipulator.update(options) }.to change{manipulator.find_entry_by_ip_address(options[:ip_address]).hostname}
+          expect( manipulator.find_entry_by_ip_address(options[:ip_address]).hostname ).to eq(options[:hostname])
+          p manipulator.find_entry_by_ip_address(options[:ip_address])
+        end
+      end
+      context "when the entry does not exist" do
+        it "does nothing" do
+          expect { manipulator.update(not_existing_options) }.not_to change{manipulator.ip_addresses.size}
+        end
+      end
+    end
+
+    context "#append" do
+      let(:options) { { ip_address: '127.0.0.1', hostname: 'new.example.com', aliases: "alias.example.com", comment: 'Some comment', priority: 5  } }
+      let(:not_existing_options) { { ip_address: '192.0.2.0', hostname: 'example.com', aliases: nil, comment: 'Some comment', priority: 5 } }
+      let(:unique_options) { { ip_address: '192.0.2.3', hostname: 'awesome.example.com', aliases: nil, comment: 'Was previously the single hostname of 192.0.2.1', unique: true } }
+      let(:unique_options_fine) { { ip_address: '192.0.2.3', hostname: 'fine.example.com', aliases: nil, comment: 'Was previously the hostname of 192.0.2.2', unique: true } }
+      let(:unique_options_refined) { { ip_address: '192.0.2.3', hostname: 'refined.example.com', aliases: nil, comment: 'Was previously an alias of 192.0.2.2', unique: true } }
+
+      context "when the entry exists by IP" do
+        it "does not update hostname, instead adds the new one as an alias" do
+          original_entry = manipulator.find_entry_by_ip_address(options[:ip_address])
+          expect { manipulator.append(options) }.not_to change{manipulator.ip_addresses.size}
+          expect( manipulator.find_entry_by_ip_address(options[:ip_address]).hostname ).to eq(original_entry.hostname)
+          expect( manipulator.find_entry_by_ip_address(options[:ip_address]).aliases ).to include("new.example.com")
+        end
+        it "updates aliases" do
+          expect { manipulator.append(options) }.not_to change{manipulator.ip_addresses.size}
+          expect( manipulator.find_entry_by_ip_address(options[:ip_address]).aliases ).to include("alias.example.com")
+        end
+        it "updates comment" do
+          expect { manipulator.append(options) }.not_to change{manipulator.ip_addresses.size}
+          expect( manipulator.find_entry_by_ip_address(options[:ip_address]).comment ).to eq(options[:comment])
+        end
+      end
+
+      context "when the entry exists by hostname" do
+        context "when tagged as unique" do
+          it "replaces it when original entry contains only name" do
+            original_entry = manipulator.find_entry_by_ip_address('192.0.2.1').dup
+            expect( original_entry.hostname ).to eq(unique_options[:hostname])
+            expect { manipulator.append(unique_options) }.not_to change{manipulator.ip_addresses.size}
+            expect( manipulator.find_entry_by_ip_address(unique_options[:ip_address]).hostname ).to eq(unique_options[:hostname])
+            expect( manipulator.find_entry_by_ip_address(original_entry.ip_address) ).to be_nil
+          end
+  
+          it "adds it when original entry has alises (and hostnames match)" do
+            original_entry = manipulator.find_entry_by_ip_address('192.0.2.2').dup
+            expect( original_entry.hostname ).to eq(unique_options_fine[:hostname])
+            
+            expect { manipulator.append(unique_options_fine) }.to change{manipulator.ip_addresses.size}.from(4).to(5)
+            expect( manipulator.find_entry_by_ip_address(unique_options_fine[:ip_address]).hostname ).to eq(unique_options_fine[:hostname])
+            refreshed_original_entry = manipulator.find_entry_by_ip_address(original_entry.ip_address)
+            expect( refreshed_original_entry ).not_to be_nil
+            expect( original_entry.aliases ).to include(refreshed_original_entry.hostname )
+            expect( original_entry.aliases.size - refreshed_original_entry.aliases.size ).to eq(1)
+          end
+
+          it "adds it when original entry has aliases (one being the hostname)" do
+            original_entry = manipulator.find_entry_by_ip_address('192.0.2.2').dup
+            expect( original_entry.aliases ).to include(unique_options_refined[:hostname])
+
+            expect { manipulator.append(unique_options_refined) }.to change{manipulator.ip_addresses.size}.from(4).to(5)
+            expect( manipulator.find_entry_by_ip_address(unique_options_refined[:ip_address]).hostname ).to eq(unique_options_refined[:hostname])
+            expect( manipulator.find_entry_by_ip_address(original_entry.ip_address) ).not_to be_nil
+            expect( manipulator.find_entry_by_ip_address(original_entry.ip_address).aliases ).not_to include(unique_options_refined[:hostname])
+          end
+
+        end
+
+        it "adds a new entry if not unique" do
+          original_entry = manipulator.find_entry_by_ip_address('192.0.2.1').dup
+          expect( original_entry.hostname ).to eq(unique_options[:hostname])
+          expect { manipulator.append(unique_options.reject {|k| k == :unique}) }.to change{manipulator.ip_addresses.size}.from(4).to(5)
+          expect( manipulator.find_entry_by_ip_address(unique_options[:ip_address]).hostname ).to eq(unique_options[:hostname])
+          expect( manipulator.find_entry_by_ip_address(original_entry.ip_address) ).not_to be_nil
+        end
+      end
+      context "when the entry does not exist" do
+        it "adds the new entry" do
+          expect { manipulator.append(not_existing_options) }.to change{manipulator.ip_addresses.size}.from(4).to(5)
+          expect( manipulator.find_entry_by_ip_address(not_existing_options[:ip_address]).hostname ).to eq('example.com')
+        end
+      end
+    end
+
+    context "#remove" do
+      context "when the entry exists" do
+        it "is removed" do
+          expect { manipulator.remove('127.0.0.1') }.to change{manipulator.ip_addresses.size}.from(4).to(3)
+        end
+      end
+      context "when the entry does not exist" do
+        it "does nothing" do
+          expect { manipulator.remove('192.0.2.0') }.not_to change{manipulator.ip_addresses.size}
+        end
+      end
+    end
+
+    # Contains will probably dissapear, as it links to entries specifically
+
+    it "ip addresses are removed works on memory" do
+      expect(manipulator.ip_addresses.size).to be(4)
+      manipulator.add(ip_address: '192.0.2.0', hostname: 'test')
+      expect(manipulator.ip_addresses.size).to be(5)
+      expect { manipulator.remove('192.0.2.0') }.to change{manipulator.ip_addresses.size}.from(5).to(4)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,38 @@
 require 'bundler/setup'
 Bundler.setup
 
+require 'simplecov'
+require 'simplecov-console'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::Console,
+  Coveralls::SimpleCov::Formatter
+]
+
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+
+def fixture_path
+  File.expand_path("../fixtures", __FILE__)
+end
+
+def fixture(*segments)
+  fakefs_status = (defined? FakeFS).nil? ? false : FakeFS.activated?
+  FakeFS.deactivate! if fakefs_status
+  fixture = File.read(File.join(fixture_path, *segments))
+  FakeFS.activate! if fakefs_status
+  fixture
+end
+
+def fixture_to_fakefs(name, filepath)
+  raise "FakeFS required but not installed or activated" unless !(defined? FakeFS).nil? && FakeFS.activated?
+
+  fixture_content = fixture(name)
+  FileUtils.mkdir_p(File.dirname(filepath))
+  File.open(filepath, "w") { |f| f.write(fixture_content) }
+end
+
 require 'hostsfile'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hostsfile
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
-- tnarik
+- Tnarik Innael
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-13 00:00:00.000000000 Z
+date: 2014-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  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: coveralls
+  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: simplecov
+  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: simplecov-console
+  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
@@ -94,6 +150,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby_gntp
+  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
@@ -114,9 +184,12 @@ files:
 - lib/hostsfile/entry.rb
 - lib/hostsfile/manipulator.rb
 - lib/hostsfile/version.rb
+- spec/entry_spec.rb
+- spec/fixtures/sample_hosts
 - spec/hostsfile_spec.rb
+- spec/manipulator_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/tnarik/hostsfile
 licenses:
 - Apache-2.0
 metadata: {}
@@ -141,5 +214,8 @@ signing_key:
 specification_version: 4
 summary: code from the hostsfile cookbook to allow reusability
 test_files:
+- spec/entry_spec.rb
+- spec/fixtures/sample_hosts
 - spec/hostsfile_spec.rb
+- spec/manipulator_spec.rb
 - spec/spec_helper.rb