linebreak 1.3.0

data/lib/aef/linebreak/commands/encode.rb

@@ -0,0 +1,73 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# TODO: If user-choices patch gets accepted, use :upcase for environment variables
+
+require 'lib/aef/linebreak' rescue LoadError require 'aef/linebreak'
+
+class Aef::Linebreak::EncodeCommand < UserChoices::Command
+  include UserChoices
+
+  # Prepare configuration sources
+  def add_sources(builder)
+    builder.add_source(
+      CommandLineSource, :usage,
+      "Usage: #$PROGRAM_NAME encode [OPTIONS] [INPUT] [OUTPUT]\n\n",
+      "Convert all linebreak encodings of a file.\n",
+      "Use the environment variable LINEBREAK_SYSTEM to specify a default output encoding.\n"
+    )
+
+    builder.add_source(EnvironmentSource, :mapping,
+      :system => 'LINEBREAK_SYSTEM'
+    )
+  end
+
+  # Define configuration options
+  def add_choices(builder)
+    systems = Aef::Linebreak::BREAK_BY_SYSTEM.keys.map{|key| key.to_s}
+    builder.add_choice(:system, :default => 'unix', :type => systems) do |cli|
+      cli.uses_option('-s', '--system SYSTEM',
+        "Output encoding system. Possible settings: #{systems.join(', ')}")
+    end
+
+    builder.add_choice(:files, :length => 0..2, :type => :pathname) {|cli| cli.uses_arglist}
+  end
+
+  # Manual option post processing
+  def postprocess_user_choices
+    if @user_choices[:files][0] and @user_choices[:files][0] != Pathname('-')
+      @user_choices[:input] = @user_choices[:files][0].open('r')
+    else
+      @user_choices[:input] = STDIN
+    end
+
+    if @user_choices[:files][1] and @user_choices[:files][1] != Pathname('-')
+      @user_choices[:output] = @user_choices[:files][1].open('w')
+    else
+      @user_choices[:output] = STDOUT
+    end
+  end
+
+  # Main program
+  def execute
+    @user_choices[:input].each_line do |line|
+      @user_choices[:output] << Aef::Linebreak.encode(line, @user_choices[:system].to_sym)
+    end
+
+    [:input, :output].each {|stream| @user_choices[stream].close }
+  end
+end

data/lib/aef/linebreak/commands/encodings.rb

@@ -0,0 +1,88 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'lib/aef/linebreak' rescue LoadError require 'aef/linebreak'
+
+class Aef::Linebreak::EncodingsCommand < UserChoices::Command
+  include UserChoices
+
+  # Prepare configuration sources
+  def add_sources(builder)
+    builder.add_source(CommandLineSource, :usage,
+      "Usage: #$PROGRAM_NAME encodings [OPTIONS] [FILE]\n\n",
+      "Detect linebreak encoding systems of a file.\n"
+    )
+  end
+
+  # Define configuration options
+  def add_choices(builder)
+    builder.add_choice(:ensure, :type => [:string]) do |cli|
+      cli.uses_option('-e', '--ensure SYSTEMLIST',
+        "Verify that given encodings are existent. Separated by commas without spaces. Possible settings: #{Aef::Linebreak::BREAK_BY_SYSTEM.keys.join(', ')}.")
+    end
+
+    builder.add_choice(:files, :type => :pathname) {|cli| cli.uses_arglist}
+  end
+
+  # Manual option post processing
+  def postprocess_user_choices
+    if @user_choices[:ensure]
+      @user_choices[:ensure] = @user_choices[:ensure].map{|string| string.to_sym }.to_set
+    end
+
+    if @user_choices[:files].empty? or @user_choices[:files].include?(Pathname('-'))
+      @user_choices[:files] = [STDIN]
+    end
+  end
+
+  # Main program
+  def execute
+    systems_by_file = {}
+
+    @user_choices[:files].each do |file|
+      unless systems_by_file[file]
+        systems_by_file[file] = Set.new
+
+        file.each_line do |line|
+          systems_by_file[file] = Aef::Linebreak.encodings(line) + systems_by_file[file]
+        end
+      end
+    end
+
+    failed = false
+
+    systems_by_file.each do |file, systems|
+      print "#{file}: " unless file == STDIN
+
+      sorted_systems = systems.sort do |a,b|
+        order = [:unix, :windows, :mac]
+        order.index(a) <=> order.index(b)
+      end
+
+      print sorted_systems.join(',')
+
+      if @user_choices[:ensure] and systems != @user_choices[:ensure]
+        failed = true
+        puts ' (failed)'
+      else
+        puts
+      end
+    end
+    
+    exit false if failed
+  end
+end

data/lib/aef/linebreak/commands/version.rb

@@ -0,0 +1,38 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'lib/aef/linebreak' rescue LoadError require 'aef/linebreak'
+
+class Aef::Linebreak::VersionCommand
+  def execute
+    name = 'Linebreak'
+    puts "#{name} #{Aef::Linebreak::VERSION}"
+    puts
+    puts 'Project: https://rubyforge.org/projects/aef/'
+    puts "RDoc: http://aef.rubyforge.org/#{name.downcase}/"
+    puts "Github: http://github.com/aef/#{name.downcase}/"
+    puts
+    puts 'Copyright 2009 Alexander E. Fischer <aef@raxys.net>'
+    # Read and print licensing information from the top of this file
+    if Gem::Version.new(RUBY_VERSION) <= Gem::Version.new('1.8.6')
+      puts File.read(__FILE__).map{|line| line[2..-1]}[3..15]
+    else
+      puts File.read(__FILE__).lines.map{|line| line[2..-1]}[3..15]
+    end
+    exit false
+  end
+end

data/lib/aef/linebreak/linebreak.rb

@@ -0,0 +1,122 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'pathname'
+require 'set'
+require 'rubygems'
+
+require 'lib/aef' rescue LoadError require 'aef'
+
+# Linebreak is Ruby library and commandline tool for conversion of text
+# between linebreak encoding formats of unix, windows or mac.
+#
+# If you want to use the String extension methods, simply use the following
+# command:
+#
+#   require 'aef/linebreak/string_extension'
+module Aef::Linebreak
+  VERSION = '1.3.0'
+  
+  BREAK_BY_SYSTEM = {
+    :unix => "\n",
+    :windows => "\r\n",
+    :mac => "\r"
+  }
+
+  SYSTEM_BY_BREAK = BREAK_BY_SYSTEM.invert
+
+  BREAK_REGEXP = /(\r\n|[\r\n])/
+
+  # Detects encoding systems of a string.
+  #
+  # Returns a Set with symbols of all encoding systems existent in the string.
+  def self.encodings(input)
+    if input.respond_to?(:to_s) then input = input.to_s
+    else raise ArgumentError, 'Input needs to be a string or must support to_s' end
+
+    occurences = Set.new
+
+    input.scan(BREAK_REGEXP).each do |linebreak|
+      occurences << SYSTEM_BY_BREAK[linebreak.first]
+    end
+
+    occurences
+  end
+
+  # Checks whether a string includes linebreaks of all the given encoding
+  # systems.
+  #
+  # One or more systems can be given as an array or an argument list of symbols.
+  #
+  # Returns true or false.
+  def self.encoding?(input, *encodings)
+    systems = BREAK_BY_SYSTEM.keys
+    
+    encodings.flatten!
+    encodings.each do |encoding|
+      unless systems.include?(encoding)
+        raise ArgumentError,
+          %{Invalid encoding system. Available systems: #{systems.join(', ')}. Arguments are expected as symbols or an array of symbols.}
+      end
+    end
+
+    Aef::Linebreak.encodings(input) == Set.new(encodings)
+  end
+
+  # Create a copy of a string with all the string's linebreaks replaced by
+  # linebreaks of a specific system or a given replacement.
+  #
+  # If given output_encoding is not a key of BREAK_BY_SYSTEM, all linebreaks
+  # are replaced with output_encoding's content itself.
+  def self.encode(input, system_or_replacement = :unix)
+    if input.respond_to?(:to_s) then input = input.to_s
+    else raise ArgumentError, 'Input needs to be a string or must support to_s' end
+
+    input.gsub(BREAK_REGEXP,
+      BREAK_BY_SYSTEM[system_or_replacement] || system_or_replacement)
+  end
+
+  # Detects encoding systems of the string.
+  #
+  # Returns a Set with symbols of all encoding systems existent in the string.
+  #
+  # This method is supposed to be used as a method of String.
+  def linebreak_encodings
+    Aef::Linebreak.encodings(self)
+  end
+
+  # Checks whether the string includes linebreaks of all the given encoding
+  # systems.
+  #
+  # One or more systems can be given as an array or an argument list of symbols.
+  #
+  # This method is supposed to be used as a method of String.
+  def linebreak_encoding?(*encodings)
+    Aef::Linebreak.encoding?(self, encodings)
+  end
+
+  # Create a copy of the string with all the string's linebreaks replaced by
+  # linebreaks of a specific system or a given replacement.
+  #
+  # If given output_encoding is not a key of BREAK_BY_SYSTEM, all linebreaks
+  # are replaced with output_encoding's content itself.
+  #
+  # This method is supposed to be used as a method of String.
+  def linebreak_encode(system_or_replacement = :unix)
+    Aef::Linebreak.encode(self, system_or_replacement)
+  end
+end

data/lib/aef/linebreak/pathname_conversion.rb

@@ -0,0 +1,44 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This class adds the type :pathname to user-choices
+class ConversionToPathname < UserChoices::Conversion
+  def self.described_by?(conversion_tag)
+    conversion_tag == :pathname
+  end
+
+  def description
+    "a pathname"
+  end
+
+  def suitable?(actual)
+    true
+  end
+
+  def convert(value)
+    case value
+    when Array
+      pathnames = []
+      
+      value.each {|path| pathnames << Pathname(path) }
+
+      pathnames
+    else
+      Pathname(value)
+    end
+  end
+end

data/lib/aef/linebreak/string_extension.rb

@@ -0,0 +1,24 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'rubygems'
+
+require 'lib/aef/linebreak' rescue LoadError require 'aef/linebreak'
+
+class String
+  include Aef::Linebreak
+end

data/spec/fixtures/mac.txt

@@ -0,0 +1 @@
+Abcdef

data/spec/fixtures/mac_unix.txt

@@ -0,0 +1,2 @@
+Abcdef
+Abcdef

data/spec/fixtures/unix.txt

@@ -0,0 +1,3 @@
+Abcdef
+Abcdef
+Abcdef

data/spec/fixtures/unix_windows.txt

@@ -0,0 +1,3 @@
+Abcdef
+Abcdef
+Abcdef

data/spec/fixtures/unix_windows_mac.txt

@@ -0,0 +1,3 @@
+Abcdef
+Abcdef
+Abcdef

data/spec/fixtures/windows.txt

@@ -0,0 +1,3 @@
+Abcdef
+Abcdef
+Abcdef

data/spec/fixtures/windows_mac.txt

@@ -0,0 +1,2 @@
+Abcdef
+Abcdef

data/spec/linebreak_spec.rb

@@ -0,0 +1,380 @@
+# Copyright 2009 Alexander E. Fischer <aef@raxys.net>
+#
+# This file is part of Linebreak.
+#
+# Linebreak is free software: you can redistribute it and/or modify it under the
+# terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'spec/spec_helper'
+
+describe Aef::Linebreak do
+  include LinebreakSpecHelper
+
+  context 'library' do
+    describe 'method "encode"' do
+      it 'should correctly work from unix to windows format' do
+        Aef::Linebreak.encode(unix_fixture, :windows).should eql(windows_fixture)
+      end
+
+      it 'should correctly work from unix to mac format' do
+        Aef::Linebreak.encode(unix_fixture, :mac).should eql(mac_fixture)
+      end
+
+      it 'should correctly work from unix to a custom format' do
+        Aef::Linebreak.encode(unix_fixture, 'fnord').should eql(custom_fixture)
+      end
+
+      it 'should correctly work from windows to unix format' do
+        Aef::Linebreak.encode(windows_fixture, :unix).should eql(unix_fixture)
+      end
+
+      it 'should correctly work from windows to mac format' do
+        Aef::Linebreak.encode(windows_fixture, :mac).should eql(mac_fixture)
+      end
+
+      it 'should correctly work from unix to a custom format' do
+        Aef::Linebreak.encode(windows_fixture, 'fnord').should eql(custom_fixture)
+      end
+
+      it 'should correctly work from mac to unix format' do
+        Aef::Linebreak.encode(mac_fixture, :unix).should eql(unix_fixture)
+      end
+
+      it 'should correctly work from mac to windows format' do
+        Aef::Linebreak.encode(mac_fixture, :windows).should eql(windows_fixture)
+      end
+
+      it 'should correctly work from unix to a custom format' do
+        Aef::Linebreak.encode(mac_fixture, 'fnord').should eql(custom_fixture)
+      end
+    end
+
+    describe 'method "encodings"' do
+      it 'should detect unix format' do
+        Aef::Linebreak.encodings(unix_fixture).should eql([:unix].to_set)
+      end
+
+      it 'should detect windows format' do
+        Aef::Linebreak.encodings(windows_fixture).should eql([:windows].to_set)
+      end
+
+      it 'should detect mac format' do
+        Aef::Linebreak.encodings(mac_fixture).should eql([:mac].to_set)
+      end
+
+      it 'should detect mixed unix and windows format' do
+        Aef::Linebreak.encodings(unix_windows_fixture).should eql([:unix, :windows].to_set)
+      end
+
+      it 'should detect mixed windows and mac format' do
+        Aef::Linebreak.encodings(windows_mac_fixture).should eql([:windows, :mac].to_set)
+      end
+
+      it 'should detect mixed mac and unix format' do
+        Aef::Linebreak.encodings(mac_unix_fixture).should eql([:mac, :unix].to_set)
+      end
+
+      it 'should detect mixed unix, windows and mac format' do
+        Aef::Linebreak.encodings(unix_windows_mac_fixture).should eql([:unix, :windows, :mac].to_set)
+      end
+
+      it 'should detect correctly strings without linebreaks' do
+        Aef::Linebreak.encodings(none_fixture).should eql(Set.new)
+      end
+    end
+
+    describe 'method "encoding?"' do
+      system_combinations = [
+        :unix,
+        :windows,
+        :mac,
+        :unix_windows,
+        :windows_mac,
+        :mac_unix,
+        :unix_windows_mac
+      ]
+
+      system_combinations.each do |system_combination|
+        system_combinations.each do |fixture_systems|
+
+          expected_systems = system_combination.to_s.split('_').inject([]) do |systems, system|
+            systems << system.to_sym
+          end
+
+          it "should correctly ensure #{expected_systems.join(' and ')} encoding (input: #{fixture_systems.to_s.split('_').join(' and ')})" do
+            fixture = send "#{fixture_systems}_fixture"
+
+            result = Aef::Linebreak.encoding?(fixture, expected_systems)
+
+            if system_combination == fixture_systems
+              result.should be_true
+            else
+              result.should be_false
+            end
+          end
+
+          if expected_systems.size > 1
+            it "should correctly ensure #{expected_systems.join(' and ')} encoding (input: #{fixture_systems.to_s.split('_').join(' and ')}; using argument list)" do
+              fixture = send "#{fixture_systems}_fixture"
+
+              result = Aef::Linebreak.encoding?(fixture, *expected_systems)
+
+              if system_combination == fixture_systems
+                result.should be_true
+              else
+                result.should be_false
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+  context 'string extension' do
+    describe 'method "linebreak_encode"' do
+      it 'should correctly work from unix to windows format' do
+        unix_fixture.linebreak_encode(:windows).should eql(windows_fixture)
+      end
+
+      it 'should correctly work from unix to mac format' do
+        unix_fixture.linebreak_encode(:mac).should eql(mac_fixture)
+      end
+
+      it 'should correctly work from unix to a custom format' do
+        unix_fixture.linebreak_encode('fnord').should eql(custom_fixture)
+      end
+
+      it 'should correctly work from windows to unix format' do
+        windows_fixture.linebreak_encode(:unix).should eql(unix_fixture)
+      end
+
+      it 'should correctly work from windows to mac format' do
+        windows_fixture.linebreak_encode(:mac).should eql(mac_fixture)
+      end
+
+      it 'should correctly work from unix to a custom format' do
+        windows_fixture.linebreak_encode('fnord').should eql(custom_fixture)
+      end
+
+      it 'should correctly work from mac to unix format' do
+        mac_fixture.linebreak_encode(:unix).should eql(unix_fixture)
+      end
+
+      it 'should correctly work from mac to windows format' do
+        mac_fixture.linebreak_encode(:windows).should eql(windows_fixture)
+      end
+
+      it 'should correctly work from unix to a custom format' do
+        mac_fixture.linebreak_encode('fnord').should eql(custom_fixture)
+      end
+    end
+
+    describe 'method "linebreak_encodings"' do
+      it 'should detect unix format' do
+        unix_fixture.linebreak_encodings.should eql([:unix].to_set)
+      end
+
+      it 'should detect windows format' do
+        windows_fixture.linebreak_encodings.should eql([:windows].to_set)
+      end
+
+      it 'should detect mac format' do
+        mac_fixture.linebreak_encodings.should eql([:mac].to_set)
+      end
+
+      it 'should detect mixed unix and windows format' do
+        unix_windows_fixture.linebreak_encodings.should eql([:unix, :windows].to_set)
+      end
+
+      it 'should detect mixed windows and mac format' do
+        windows_mac_fixture.linebreak_encodings.should eql([:windows, :mac].to_set)
+      end
+
+      it 'should detect mixed mac and unix format' do
+        mac_unix_fixture.linebreak_encodings.should eql([:mac, :unix].to_set)
+      end
+
+      it 'should detect mixed unix, windows and mac format' do
+        unix_windows_mac_fixture.linebreak_encodings.should eql([:unix, :windows, :mac].to_set)
+      end
+
+      it 'should detect correctly strings without linebreaks' do
+        none_fixture.linebreak_encodings.should eql(Set.new)
+      end
+    end
+
+    describe 'method "linebreak_encoding?"' do
+      system_combinations = [
+        :unix,
+        :windows,
+        :mac,
+        :unix_windows,
+        :windows_mac,
+        :mac_unix,
+        :unix_windows_mac
+      ]
+
+      system_combinations.each do |system_combination|
+        system_combinations.each do |fixture_systems|
+
+          expected_systems = system_combination.to_s.split('_').inject([]) do |systems, system|
+            systems << system.to_sym
+          end
+
+          it "should correctly ensure #{expected_systems.join(' and ')} encoding (input: #{fixture_systems.to_s.split('_').join(' and ')})" do
+            fixture = send "#{fixture_systems}_fixture"
+
+            result = fixture.linebreak_encoding?(expected_systems)
+
+            if system_combination == fixture_systems
+              result.should be_true
+            else
+              result.should be_false
+            end
+          end
+
+          if expected_systems.size > 1
+            it "should correctly ensure #{expected_systems.join(' and ')} encoding (input: #{fixture_systems.to_s.split('_').join(' and ')}; using argument list)" do
+              fixture = send "#{fixture_systems}_fixture"
+
+              result = fixture.linebreak_encoding?(*expected_systems)
+
+              if system_combination == fixture_systems
+                result.should be_true
+              else
+                result.should be_false
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+
+  context 'commandline tool' do
+    describe '"version" command' do
+      it 'should display correct version and licensing information with the version argument' do
+        `#{executable_path} version`.should eql(version_message)
+      end
+
+      it 'should display correct version and licensing information with the --version argument' do
+        `#{executable_path} --version`.should eql(version_message)
+      end
+
+      it 'should display correct version and licensing information with the -v argument' do
+        `#{executable_path} -v`.should eql(version_message)
+      end
+
+      it 'should display correct version and licensing information with the -V argument' do
+        `#{executable_path} -V`.should eql(version_message)
+      end
+    end
+
+    describe '"encode" command' do
+      it 'should use unix as default format' do
+        `#{executable_path} encode #{fixture_path('windows.txt')}`.should eql(unix_fixture)
+      end
+
+      it 'should accept -s option to specify output format' do
+        `#{executable_path} encode -s mac #{fixture_path('unix.txt')}`.should eql(mac_fixture)
+      end
+
+      it 'should also accept --system option to specify output format' do
+        `#{executable_path} encode --system windows #{fixture_path('mac.txt')}`.should eql(windows_fixture)
+      end
+
+      it 'should abort on invalid output formats' do
+        POpen4.popen4("#{executable_path} encode -s fnord #{fixture_path('mac.txt')}") do |stdout, stderr, stdin, pid|
+          stdout.read.should be_empty
+          stderr.read.should_not be_empty
+        end
+      end
+
+      it 'should accept LINEBREAK_SYSTEM environment variable to specify output format' do
+        env(:LINEBREAK_SYSTEM => 'mac') do
+          `#{executable_path} encode #{fixture_path('windows.txt')}`.should eql(mac_fixture)
+        end
+      end
+
+      it 'should use output format specified with -s even if LINEBREAK_SYSTEM environment variable is set' do
+        env(:LINEBREAK_SYSTEM => 'windows') do
+          `#{executable_path} encode -s mac #{fixture_path('unix.txt')}`.should eql(mac_fixture)
+        end
+      end
+
+      it 'should use a second argument as target file' do
+        temp_file = Tempfile.open('linebreak_spec')
+        location = Pathname(temp_file.path)
+        temp_file.close
+        location.delete
+
+        `#{executable_path} encode --system windows #{fixture_path('unix.txt')} #{location}`.should be_empty
+
+        location.read.should eql(windows_fixture)
+        location.delete
+      end
+    end
+
+    describe '"encodings" command' do
+      it "should correctly detect the linebreak encodings of a file" do
+        POpen4.popen4("#{executable_path} encodings #{fixture_path('mac.txt')}") do |stdout, stderr, stdin, pid|
+          stdout.read.should eql("#{fixture_path('mac.txt')}: mac\n")
+        end.exitstatus.should eql(0)
+      end
+
+      it "should correctly detect the linebreak encodings of multiple files" do
+        files = %w{unix_windows.txt windows_mac.txt mac_unix.txt unix_windows_mac.txt}
+        files = files.map{|file| fixture_path(file)}
+
+        POpen4.popen4("#{executable_path} encodings #{files.join(' ')}") do |stdout, stderr, stdin, pid|
+          output = stdout.read
+          output.should include("#{files[0]}: unix,windows\n")
+          output.should include("#{files[1]}: windows,mac\n")
+          output.should include("#{files[2]}: unix,mac\n")
+          output.should include("#{files[3]}: unix,windows,mac\n")
+        end.exitstatus.should eql(0)
+      end
+
+      it "should correctly ensure the linebreak encodings of a valid file" do
+        POpen4.popen4("#{executable_path} encodings --ensure unix #{fixture_path('unix.txt')}") do |stdout, stderr, stdin, pid|
+          output = stdout.read
+          output.should eql("#{fixture_path('unix.txt')}: unix\n")
+        end.exitstatus.should eql(0)
+      end
+
+      it "should correctly ensure the linebreak encodings of an invalid file" do
+        POpen4.popen4("#{executable_path} encodings --ensure mac #{fixture_path('unix_windows.txt')}") do |stdout, stderr, stdin, pid|
+          output = stdout.read
+          output.should eql("#{fixture_path('unix_windows.txt')}: unix,windows (failed)\n")
+        end.exitstatus.should eql(1)
+      end
+
+      it "should correctly ensure the linebreak encodings of multiple files" do
+        files = %w{unix_windows.txt windows_mac.txt mac_unix.txt unix_windows_mac.txt}
+        files = files.map{|file| fixture_path(file)}
+
+        POpen4.popen4("#{executable_path} encodings --ensure windows,unix #{files.join(' ')}") do |stdout, stderr, stdin, pid|
+          output = stdout.read
+          output.should include("#{files[0]}: unix,windows\n")
+          output.should_not include("#{files[0]}: unix,windows (failed)\n")
+          output.should include("#{files[1]}: windows,mac (failed)\n")
+          output.should include("#{files[2]}: unix,mac (failed)\n")
+          output.should include("#{files[3]}: unix,windows,mac (failed)\n")
+        end.exitstatus.should eql(1)
+      end
+    end
+  end
+end