line_ender 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
-SHA512: 
-  data.tar.gz: 9186cd233ab899bfb47b425f4039fda71d7d840692e20bdc355ee0bc878c0ab3b945f5905a10bfbf0b1d74974b0b8d917e1c5ee7e37955f978e6a2ac89aff24e
-  metadata.gz: 3394b3cdaa70f8a5d7542251a514d45ff1f04338c5f58a99dffe920c9cf97d4e0856ca7dd35dc81be9b8eb541ef07f128e3d8330a1133a967bb921b7cd69d724
 SHA1: 
-  data.tar.gz: ea6ae3546c2020c688b55afcc63dcd37a043f294
-  metadata.gz: 0ae0ea43faecf40c84ce5f6d8610733bfdd2030f
+  data.tar.gz: 0a8805fe53c0e3b98af8ffb911b9486b5d21033d
+  metadata.gz: ff506642f441d4fd8a53aff88a65bbdc806b1d4c
+SHA512: 
+  data.tar.gz: a6a6147ba4e9f07754e98f80200980c862165335a2989e10354271c2c29e3c951aac85620ad1e374ed6a5278271373c79d7e9ce130d2e0455824337969189a08
+  metadata.gz: 222a545605d345cb95c07e6a92417996374f7a1972c5b2e3389f27675c8d138a1bce7fcbf5a210f935aebdac0d33bd1cd149ee826a90293bc054c027bac7d987

data/lib/le

@@ -1,78 +1,64 @@
-#!/usr/bin/env ruby
-# == Synopsis
-# le: This is program that replaces line endings of a file. It either does an inplace update or  will write to another file with (-o) switch.
-# The default line ending is Unix (-u), but other line endings are Windows (-w) or Mac (-m).
-#    
-# == Note
-#  The -u, -m, and -w flags are mutually exclusive. (Can only choose one).
-#
-# == Usage
-# le [OPTION] ... INPUTFILE
-#
-# -h, --help:    show help
-#
-# -w, --windows: gives the file line endings of carriage return + line feed (\r\n)
-#
-# -u, --unix:    gives the file line endings of line feed (\n) (default)
-#
-# -m, --mac:     gives the file line endings of carriage return (\r)
-#
-# -o, --out:     will write the output to a file with this name
-#
-# INPUTFILE: The file you want to modify the line endings for.
-
+#! /usr/bin/env ruby
 require 'rubygems'
-require 'getoptlong'
-require 'rdoc/usage'
+require 'trollop'
 require 'line_ender'
 
 include LineEnder
 
-opts = GetoptLong.new(
-  [ '--windows', '-w', GetoptLong::OPTIONAL_ARGUMENT ],
-  [ '--mac', '-m', GetoptLong::OPTIONAL_ARGUMENT ],
-  [ '--unix', '-u', GetoptLong::OPTIONAL_ARGUMENT ],
-  [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
-  [ '--out', '-o', GetoptLong::OPTIONAL_ARGUMENT ]
-)
-
-outfile = nil
-infile = nil
-ending = nil
-opts.each do |opt, arg|
-  case opt
-	  when '--windows'
-		  RDoc::usage if ending
-			ending = LineEnder::Ending::Windows
-	  when '--unix'
-		  RDoc::usage if ending
-			ending = LineEnder::Ending::Unix
-	  when '--mac'
-		  RDoc::usage if ending
-			ending = LineEnder::Ending::Mac
-    when '--help'
-      RDoc::usage
-    when '--out'
-		  outfile = arg
-  end
+opts = Trollop::options do
+  banner <<-EOS
+Synopsis: le is a line ender script to be used from the command prompt if you put it in your path
+Usage: le [flags] [-o outfile] inputfile
+Note: don't have to set --no-unix flag if looking for different endings ... will override.
+Flags:
+EOS
+  opt :windows, "Windows ending", :default => false
+  opt :unix, "Unix ending", :default => true
+  opt :mac, "Mac ending", :default => false
+  opt :debug, "Debug mode", :default => false
+  opt :output, "Output to another file", :type => :string
 end
 
-ending = LineEnder::Ending::Unix unless ending
+p opts if opts[:debug]
+
+outfile = opts[:output]
+ending = nil
+ending = opts[:windows] ? LineEnder::Ending::Windows : ending
+ending = opts[:mac] ? LineEnder::Ending::Mac : ending 
+ending = opts[:unix] ? LineEnder::Ending::Unix : ending if ending.nil?
 
 if ARGV.length != 1
-  puts "***---Missing INPUTFILE argument---***"
-	puts
-	RDoc::usage
+  puts "Missing or too many INPUTFILE argument(s)."
+  puts "example: le -m -o fixed.txt somefile.txt"
+  puts "Try the -h flag for help on flags"
   exit 0
 end
 
-infile = ARGV.shift
+infile = ARGV[0]
 
-if outfile
-	 output_to_file( infile, ending, outfile )
-else
-	 output_to_file( infile, ending )
+if opts[:debug]
+  puts "outfile: #{outfile}, #{outfile.inspect}"
+  puts "infile: #{infile}, #{infile.inspect}" 
+  puts "ending: #{ending.inspect}"
 end
 
+ending_string = ""
+case ending
+when LineEnder::Ending::Windows
+  ending_string = "windows"
+when LineEnder::Ending::Unix
+  ending_string = "unix"
+when LineEnder::Ending::Mac
+  ending_string = "mac"
+else
+  ending_string = "unix"
+end
 
+if outfile
+  output_to_file( infile, ending, outfile )
+  puts "Succesfully created #{outfile}, with #{ending_string}-style line endings!"
+else
+  output_to_file( infile, ending )
+  puts "Successfully updated #{infile}, with #{ending_string}-style line endings!"
+end
 

data/lib/line_ender.rb

@@ -3,112 +3,120 @@ require 'rubygems'
 
 module LineEnder
 
- module Ending
-   Mac = 1
-   Windows = 2
-   Unix = 3
-
-   def self.valid?(value)
-     return true if value == Ending::Mac || value == Ending::Windows || value == Ending::Unix
-     return false
-   end
- end
-
- def initialize
-   @debug = false
- end
-
- def self.included(cls)
-   include Ending
- end
-
- def output_to_file(input_filepath, ending, output_filename='')
-   raise RuntimeError, "Something is wrong with the input input filepath!" unless valid_filepath?(input_filepath)
-   raise RuntimeError, "Something is wrong with the 'Ending' parameter passed in!" unless valid_ending?(ending)
-   output_filepath = get_output_filepath(input_filepath, output_filename)
-   puts "output filepath = #{output_filepath}" if @debug
-
-   #this will only happen for an inplace file update
-   if (output_filepath == input_filepath)
-     raise RuntimeError, "File is not writeable!" unless File.writable?(output_filepath)
-   end
-
-   file_as_string = file_to_string(input_filepath)
-   fixed_file_string = change_line_endings(file_as_string, ending)
-   string_to_file(fixed_file_string, output_filepath)
-   return true
- end
-
- def output_to_string(input_filepath, ending)
-   raise RuntimeError, "Something is wrong with the input input filepath!" unless valid_filepath?(input_filepath)
-   raise RuntimeError, "Something is wrong with the 'Ending' parameter passed in!" unless valid_ending?(ending)
-
-   file_as_string = file_to_string(input_filepath)
-   change_line_endings(file_as_string, ending)
- end
-
- protected
-
- def get_output_filepath(input_filepath, output_filename)
-   input_path = File.expand_path(input_filepath).split(::File::Separator)
-   input_filename = input_path.last
-   puts "in get_output_filepath ... input_path = #{input_path}" if @debug
-   puts "in get_output_filepath ... input_filename = #{input_filename}" if @debug
-   output_filepath = ''
-   if output_filename.empty?
-     output_filepath = input_filepath
-   else
-     output_path = output_filename.split(::File::Separator)     
-     output_filename = output_path.last
-     if output_path.first == output_filename
-       if input_filename == output_filename
-         output_filepath = input_filepath
-       else
-         input_path.pop
-         output_filepath = File.join(input_path,output_filename)
-         puts "in get_output_filepath ... output_filepath = #{output_filepath}" if @debug
-       end
-     else
-       #the output_filename is a path ... lets expand it
-       output_path = File.expand_path(output_filename).split(::File::Separator)     
-       output_filepath = File.join(output_path)
-     end
-   end
-   output_filepath 
- end
-
- def string_to_file(fixed_file_string, output_filepath)
-     File.delete(output_filepath) if File.exists?(output_filepath)
-     File.open(output_filepath, "wb"){|out_file| out_file.write(fixed_file_string)}
- end
-
- def change_line_endings(file_as_string, ending)
-   fixed_file_string = ''
-   fixed_file_string = file_as_string.gsub(/(\n)|(\r\n?)/, "\n") if ending == Ending::Unix
-   fixed_file_string = file_as_string.gsub(/(\n)|(\r\n?)/, "\r") if ending == Ending::Mac
-   fixed_file_string = file_as_string.gsub(/(\n)|(\r\n?)/, "\r\n") if ending == Ending::Windows
-   fixed_file_string
- end
-
- def file_to_string(filepath)
-   file = File.open(filepath, "rb")
-   file_string = file.read
-   file.close
-   file_string
- end
-
- def valid_ending?(ending) 
-   raise RuntimeError, "Ending parameter is required!" unless ending
-   raise RuntimeError, "Ending parameter must be of type Ending" unless Ending.valid?(ending)
-   return true
- end
-
- def valid_filepath?(filepath)
-   raise RuntimeError, "Filepath parameter is required!" unless filepath
-   raise RuntimeError, "File with that filepath is not found!" unless File.exists?(filepath)
-   raise RuntimeError, "File is not readable!" unless File.readable?(filepath)
-   return true
- end
+  module Ending
+    Mac = "\r"
+    Windows = "\r\n"
+    Unix = "\n"
+
+    def self.valid?(value)
+      value == Ending::Mac || value == Ending::Windows || value == Ending::Unix
+    end
+  end
+
+  def initialize
+  end
+
+  def self.included(cls)
+    include Ending
+  end
+
+  def output_to_file(input_filepath, ending, output_filename='')
+    raise RuntimeError, "Something is wrong with the input input filepath!" unless valid_filepath?(input_filepath)
+    raise RuntimeError, "Something is wrong with the 'Ending' parameter passed in!" unless valid_ending?(ending)
+    output_filepath = get_output_filepath(input_filepath, output_filename)
+    debug_print "output filepath = #{output_filepath}"
+
+    #this will only happen for an inplace file update
+    if (output_filepath == input_filepath)
+      raise RuntimeError, "File is not writeable!" unless File.writable?(output_filepath)
+    end
+
+    file_as_string = file_to_string(input_filepath)
+    fixed_file_string = change_line_endings(file_as_string, ending)
+    string_to_file(fixed_file_string, output_filepath)
+    return true
+  end
+
+  def output_to_string(input_filepath, ending)
+    raise RuntimeError, "Something is wrong with the input filepath!" unless valid_filepath?(input_filepath)
+    raise RuntimeError, "Something is wrong with the 'Ending' parameter passed in!" unless valid_ending?(ending)
+
+    file_as_string = file_to_string(input_filepath)
+    change_line_endings(file_as_string, ending)
+  end
+
+  protected
+
+  def debug_print(message)
+    puts message if $DEBUG
+  end
+
+  def get_output_filepath(input_filepath, output_filename)
+    input_path = File.expand_path(input_filepath).split(::File::Separator)
+    input_filename = input_path.last
+    debug_print "in get_output_filepath ... input_path = #{input_path}"
+    debug_print "in get_output_filepath ... input_filename = #{input_filename}"
+    output_filepath = ''
+    #do we have a value in output_file?
+    #if we don't  ... assume writing to same file
+    #if we do ...
+    #is output_filename a path?
+    #if it is ... return that
+    #if it is not ... take input_path and join this filename
+    if output_filename.empty?
+      output_filepath = input_filepath
+    else
+      output_path = output_filename.split(::File::Separator)     
+      output_filename = output_path.last
+      if output_path.first == output_filename
+        if input_filename == output_filename
+          output_filepath = input_filepath
+        else
+          input_path.pop
+          output_filepath = File.join(input_path,output_filename)
+          debug_print "in get_output_filepath ... output_filepath = #{output_filepath}"
+        end
+      else
+        #the output_filename is a path ... lets expand it
+        output_path = File.expand_path(output_filename).split(::File::Separator)     
+        output_filepath = File.join(output_path)
+      end
+    end
+    output_filepath 
+  end
+
+  def string_to_file(fixed_file_string, output_filepath)
+    File.delete(output_filepath) if File.exists?(output_filepath)
+    File.open(output_filepath, "wb"){|out_file| out_file.write(fixed_file_string)}
+  end
+
+  def change_line_endings(file_as_string, ending)
+    fixed_file_string = ''
+    fixed_file_string = file_as_string.gsub(/(\n)|(\r\n?)/, "\n") if ending == Ending::Unix
+    fixed_file_string = file_as_string.gsub(/(\n)|(\r\n?)/, "\r") if ending == Ending::Mac
+    fixed_file_string = file_as_string.gsub(/(\n)|(\r\n?)/, "\r\n") if ending == Ending::Windows
+    fixed_file_string
+  end
+
+  def file_to_string(filepath)
+    file = File.open(filepath, "rb")
+    file_string = file.read
+    file.close
+    file_string
+  end
+
+  def valid_ending?(ending) 
+    raise RuntimeError, "Ending parameter is required!" unless ending
+    raise RuntimeError, "Ending parameter must be of type Ending" unless Ending.valid?(ending)
+    return true
+  end
+
+  def valid_filepath?(filepath)
+    raise RuntimeError, "Filepath parameter is required!" unless filepath
+    raise RuntimeError, "File with that filepath is not found!" unless File.exists?(filepath)
+    raise RuntimeError, "File is not readable!" unless File.readable?(filepath)
+    return true
+  end
 
 
 end

data/lib/test_line_ender.rb

@@ -11,7 +11,6 @@ class TestLineEnder < Test:: Unit::TestCase
 
   def setup
     puts 'setup'
-    @debug = true
     @tle = TLE.new
     @file1 = "file1.txt"
     @file2 = "file2.txt"
@@ -25,44 +24,66 @@ class TestLineEnder < Test:: Unit::TestCase
   end
   
   def test_mac_to_unix_written_to_new_file
-    puts "in test: #{__method__} ..."
-    start_value = "a\rb\rc\r"
-    fixed_value = "a\nb\nc\n"
-    fs = helper_for_file_test(start_value, fixed_value , LineEnder::Ending::Unix, true)
+    puts "---> in test: #{__method__} ..."
+    start_value = ["a", "b", "c"].join("\r")
+    expected_value = ["a", "b", "c"].join("\n")
+
+    helper_print_start_values(start_value, expected_value)
+    output_string = helper_for_file_test(start_value, expected_value , LineEnder::Ending::Unix, true)
+    helper_print_output_value(output_string)
+
     assert(File.exists?(@file2), "#{__method__} ... has not written to new file")
-    assert(fs == fixed_value, "#{__method__} ... fixed file is not a match to expected value") if File.exists?(@file2)
+    assert(output_string == expected_value, "#{__method__} ... output string is not a match to expected value") if File.exists?(@file2)
   end
 
   def test_mac_to_windows_write_to_same_file
-    puts "in test: #{__method__} ..."
-    start_value = "a\rb\rc\r\r\r"
-    fixed_value = "a\r\nb\r\nc\r\n\r\n\r\n"
-    fs = helper_for_file_test(start_value, fixed_value , LineEnder::Ending::Windows)
-    assert(fs == fixed_value, "#{__method__} ... fixed file is not a match to expected value")
+    puts "---> in test: #{__method__} ..."
+    start_value = ["a", "b", "c"].join("\r")
+    expected_value = ["a", "b", "c"].join("\r\n")
+
+    helper_print_start_values(start_value, expected_value)
+    output_string = helper_for_file_test(start_value, expected_value , LineEnder::Ending::Windows)
+    helper_print_output_value(output_string)
+
+    assert(output_string == expected_value, "#{__method__} ... output string is not a match to expected value")
   end
 
   def test_mac_to_windows_string_dump
-    puts "in test: #{__method__} ..."
-    start_value = "a\rb\rc\r\r"
-    fixed_value = "a\r\nb\r\nc\r\n\r\n"
+    puts "---> in test: #{__method__} ..."
+    start_value = ["a", "b", "c"].join("\r")
+    expected_value = ["a", "b", "c"].join("\r\n")
+
+    helper_print_start_values(start_value, expected_value)
     helper_write_file(@file1, start_value)
-    helper_for_hexdump("start", @file1) if @debug
-    fs= @tle.output_to_string(@file1, LineEnder::Ending::Windows)
-    assert(fs == fixed_value, "#{__method__} ... fixed file is not a match to expected value")
+    helper_for_hexdump("start", @file1)
+    output_string= @tle.output_to_string(@file1, LineEnder::Ending::Windows)
+    helper_print_output_value(output_string)
+
+    assert(output_string == expected_value, "#{__method__} ... output string is not a match to expected value")
+
+  end
+
+  def helper_print_start_values(start_value, expected_value)
+    puts("start value ... getting pushed into file1.txt: #{start_value.inspect}")
+    puts("expected value: #{expected_value.inspect}")
+  end
+
+  def helper_print_output_value(output_value)
+    puts("output value (as string): #{output_value.inspect}")
   end
 
-  def helper_for_file_test(start_value, fixed_value, ending_to_use, new_output_file = false)
+  def helper_for_file_test(start_value, expected_value, ending_to_use, new_output_file = false)
     helper_write_file(@file1, start_value)
-    helper_for_hexdump("start", @file1) if @debug
+    helper_for_hexdump("start", @file1) 
     if new_output_file
       @tle.output_to_file( @file1, ending_to_use, @file2 )
-      fixed_file = @file2
+      output_file = @file2
     else
       @tle.output_to_file( @file1, ending_to_use)
-      fixed_file = @file1
+      output_file = @file1
     end
-    helper_for_hexdump("fixed", fixed_file) if File.exists?(fixed_file) && @debug
-    helper_read_file(fixed_file)
+    helper_for_hexdump("output", output_file) if File.exists?(output_file)
+    helper_read_file(output_file) if File.exists?(output_file)
   end
 
   def helper_write_file(file_name, value)
@@ -78,7 +99,7 @@ class TestLineEnder < Test:: Unit::TestCase
       file = File.open(file_name, "rb")
       file.binmode
       file_string = file.read
-      puts "contents of file #{file_name} as a string ... #{file_string.inspect}" if @debug
+      #puts "contents of file #{file_name} as a string ... #{file_string.inspect}" 
     end
     file_string
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: line_ender
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Rich Krueger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-08-28 00:00:00 Z
+date: 2014-06-28 00:00:00 Z
 dependencies: []
 
 description: A little mixin to change the line endings of files. Supports Mac, Unix, and Windows line ending conversions.
@@ -44,8 +44,8 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - *id001
-requirements: []
-
+requirements: 
+- trollop, v2.0
 rubyforge_project: 
 rubygems_version: 2.0.7
 signing_key: