attic-path 0.0.1

data/README.md

@@ -0,0 +1,107 @@
+Attic-Path
+========
+
+A replacement for gets.chomp.
+
+About
+=====
+
+Attic Path is a gem that gives you more options to gets.chomp.
+With Attic Path you can browse your system while being in the gets.chomp.
+The user can select files and add them into an array.
+Here are the current available options for Attic Path.
+
+
+
+Options
+======
+
+There are a number of options you can use with Attic-Path
+
+List of options:
+* submit - If set to true the user has to type the submit_command before being able to store the string.
+* submit_command - Set the name for the submit command.
+* no_blank - If you don't want the user to submit a blank string, set this to true.
+* no_blank_error - Set the error message for the no_blank option
+* flush - Set flush to true to let Attic-Path STDOUT.flush automatically
+* pathing - Set pathing to true if you want the user to be able to see in which directory he is. Pathing is also needed for the next few options.
+* file_id - Set this to true if you want all files / folders to have a unique id per folder. What this does is makes it easier to navigate around or select files/folder with the grab method.
+* cd - Set this to true in order to let the user cd around his system while being inside the input.
+* ls - Set to true if you want the user to be able to use ls command while inside the input
+* lsa - Set to true in order to enable the "ls -a" command, shows all files including hidden files in a folder.
+* mv - Set to true if you want the user to be able to use mv command while inside the input
+* grab - Set to true if you want the user to be able to use the grab command while inside the input. The grab command lets the user 'grab' a certain file. When he does this the file will be put into an array, and you can get that array out of the output.
+* grab_count - Set max allowed files that can be inserted into array, set true if unlimited 
+* grab_exit - Set to true if you want to exit input once the array has enough item
+* grab_no_file - Set error message if no file is selected
+* grab_full - Set error message for when grab is full
+* grab_not_found - Set error message for when grab isn't found
+
+
+
+Installing
+=======
+
+Just require the gem and add this to your code to adjust the options.
+
+## AtticPath Options  
+```ruby
+attic_c = AtticPathCommands.new do |c|
+
+  c.submit = true # Set to true if user has to use the submit_command before submitting
+
+  c.submit_command = "submit" # If submit if true then you can set your submit command
+
+  c.no_blank = true # If you don't want blank inputs set this to true
+
+  c.no_blank_error = "Input can't be blank" # If no_blank is true, set your error message
+  
+  c.flush = true # Set to true if you want AtticInput to automatically do STDOUT.flush
+
+
+
+  c.pathing = true # Set to true if you want to be able to browse your system 
+                   # and use any available terminal commands that are set to true
+  
+  if c.pathing == true # These options are only available if pathing is enabled
+    c.file_id = true # Set to true to enable file id, example: instead of cd Users you can do cd -1
+
+    c.cd = true # Set to true if you want the cd command to be usable
+
+    c.ls = true # Set to true if you want the ls command to be usable
+    c.lsa = nil # Set to true if you want the ls -a command to be usable
+
+    c.mv = true # Set to true if you want the mv command to be usable
+    
+    c.grab = true # Set to true if you want to be able to put files in an array
+    c.grab_count = 4 # Set max allowed files that can be inserted into array, set true if unlimited 
+    c.grab_exit = nil # Set to true if you want to exit input once the array has enough item
+    c.grab_no_file = "You didn't select a file." # Set error message if no file is selected
+    c.grab_full = "Can't select more than 4 items" # Set error message for when grab is full
+    c.grab_not_found = "File you typed in wasn't found" # Set error message for when grab isn't found
+  end
+end
+```
+
+AtticPath Input Functions                              
+=========================
+
+# attic_path = AtticPathInput.new(attic_c)
+New input, you don't HAVE to repeat this if your app is straight forward
+
+# attic_path.input
+This is the input, like gets.chomp
+
+# attic_path.output
+This is the output for your input, it'll just output a string
+
+# attic_path.array
+This is the output but as an array
+
+# puts attic_path.grab
+This is the grab function. An array with all the files / folders that the user stored
+
+Notes
+=====
+
+Please note that this gem is still beta version, I am not responsible if something breaks when using this. Use at own risk.

data/lib/attic-path.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+require "fileutils"
+require "terminal-table"
+
+# require File.expand_path("../../lib/attic_path_input.rb", __FILE__)
+# require File.expand_path("../../lib/attic_path_commands.rb", __FILE__)
+
+$:.unshift File.dirname(__FILE__)
+%w(attic_path_commands attic_path_input).each do |file|
+  require "attic-path/#{file}"
+end
+
+begin
+  require 'fileutils'
+  require 'terminal-table'
+rescue LoadError
+  puts "\n You must have fileutils and terminal-table installed in order to use attic-path."
+  puts "fileutils should already be installed."
+  puts "gem install terminal-table"
+  puts "if this still doesn't fix this problem then you might not have fileutils"
+  exit 1
+end

data/lib/attic-path/attic_path_commands.rb

@@ -0,0 +1,7 @@
+class AtticPathCommands
+  attr_accessor :submit, :submit_command, :no_blank, :no_blank_error, :flush, :pathing, :file_id, :cd, :ls, :mv, :lsa, :grab, :grab_count, :grab_exit, :grab_no_file, :grab_full, :grab_not_found
+  
+  def initialize(&block)
+    instance_eval(&block) if block_given?
+  end
+end

data/lib/attic-path/attic_path_input.rb

@@ -0,0 +1,455 @@
+class AtticPathInput
+  
+  attr_accessor :attic_c
+  
+  def initialize(attic_c)
+    @attic_c = attic_c
+  end
+  
+  ############################################
+  #                Dir setup                 #
+  ############################################
+  
+  # Code starts here, if the pathing is true then it will be enabled.
+  def input
+    if attic_c.pathing == true
+      @grab_array = []
+      @grab_num = 0
+      current_dir(".")
+    else
+      command()
+    end
+  end
+
+  # Whenever a dir is requested, it will be checked here if it exists or not.
+  def check_dir(input)
+    if File.directory? File.join(@the_dir, input)
+      current_dir(input)
+    elsif File.exist? File.join(@the_dir, input)
+      puts "\nThe path #{File.join(@the_dir, input)} is a file."
+      command()
+    else
+      puts "\nThe path #{File.join(@the_dir, input)} Doesn't exist."
+      command()
+    end
+  end
+
+  # The current dir the user is in is set here, everytime the location is updated
+  # the @the_dir variable changes.
+  def current_dir(input)
+    Dir.chdir(input)
+    @the_dir =  Dir.getwd()
+    command()
+  end
+  
+  # Checks if a certain file exists when asked for.
+  def check_file(file)
+    if File.exists? file
+    else
+      puts "File or folder doesn't exist"
+      command()
+    end
+  end
+  
+  # All the files/folders of the current_dir are stored here, if file_ids are enabled
+  # every file/folder will have a unique ID.
+  def all_files
+    Dir.chdir(@the_dir)
+    @all_files = Dir.glob("*");
+    if attic_c.file_id == true
+      file_ids()
+    end
+  end
+  
+  # The ID for each file/folder is set here.
+  def file_ids
+    @file_ids = []
+    i = 0
+    @all_files.each do |f|
+      @file_ids << i 
+      i += 1
+    end
+  end
+  
+  ############################################
+  #              Command inputs              #
+  ############################################
+  
+  # The input starts here, whenever a command has been set, and Attic Path isn't done
+  # this function will be called.
+  def command
+    # If pathing is true, display the current_dir.
+    if attic_c.pathing == true
+      puts "\n>>#{@the_dir}"
+      all_files()
+    end
+    
+    # STDOUT.flush if set it is set to true in the options
+    flush()
+    
+    # Converts the input to an array, in order to set multiple functions in 1 input
+    @input = gets.chomp
+    @input_array = @input.scan(/\w+/)
+    @input = @input.split(" ")
+    
+    # All the commands availabe
+    
+    if @input[0] == "--help"
+      help()
+      
+    elsif @input[0] == "cd" 
+      cd()
+    
+    elsif @input[0] == "ls"
+      ls()
+      
+    elsif @input[0] == "cp"
+      cp()
+    
+    elsif @input[0] == "mv"
+      mv()
+      
+    elsif @input[0] == "grab"
+      grabfile()
+
+    else
+      submit()
+    end
+  end
+  
+  ############################################
+  #            Command functions             #
+  ############################################
+  
+  # The STDOUT.flush if true
+  def flush
+    if attic_c.flush == true
+      STDOUT.flush
+    end
+  end
+  
+  # --help function
+  def help
+    puts "Help is here!"
+    command()
+  end
+  
+  # The cd function to move from dir to dir
+  def cd
+    if attic_c.cd == true
+      if @input[1] == "--help"
+        puts "cd help"
+        command()
+      else
+        if @input[1] == nil || @input[1][0] == "/"
+          if @input[1] == nil
+            current_dir("/")
+          else
+            current_dir(File.join("/", @input[1][1..999999]))
+          end
+        elsif @input[1][0..1] == "~/"
+          current_dir(File.join(ENV["HOME"], @input[1][2..999999]))
+        elsif @input[1][0] == "#" && attic_c.file_id == true
+          i = 0
+          @file_ids.each do |f|
+            if @input[1] == "##{f}"
+              check_dir(@all_files[f])
+              break
+            end
+            if i+1 == @file_ids.count
+              puts "Folder id wasn't found"
+              command()
+            end
+            i += 1 
+          end
+        else
+          check_dir(@input[1])
+        end
+      end
+    else
+      invalid()
+    end
+  end
+  
+  # The ls method
+  def ls
+    if attic_c.ls == true
+      if @input[1] == "--help"
+        puts "ls help"
+        command()
+      else
+        Dir.chdir(@the_dir)
+        if @input[1] == "-a" && attic_c.lsa == true
+          ls = Dir.glob("{*,.*}");
+        else
+          ls = Dir.glob("*");
+        end
+        rows = []
+        if ls.count == 1
+          if attic_c.file_id == true
+            rows << ["#0", ls[0]]
+          else
+            rows << [ls[0]]
+          end
+          table = Terminal::Table.new :rows => rows
+          puts table
+        else
+          i = 0
+          while i < ls.count
+            if attic_c.file_id == true
+              rows << ["##{@file_ids[i]}", ls[i], "##{@file_ids[i+1]}", ls[i+1]]
+              i+= 2
+            else
+              rows << [ls[i], ls[i+1]]
+              i+= 2
+            end
+          end
+          table = Terminal::Table.new :rows => rows
+          puts table
+        end
+        command()
+      end
+    else
+      invalid()
+    end
+  end
+  
+  # The mv method
+  def mv
+    if @input[1] != nil && @input[2] != nil
+      file_1 = File.join(@the_dir, @input[1])
+      file_2 = File.join(@the_dir, @input[2])
+      if @input[1][0] == "#"
+        number1 = @input[1][1..999].to_i
+        number2 = @input[2][1..999].to_i
+        
+        file_id_1 = File.join(@the_dir, @all_files[number1])
+        file_id_2 = File.join(@the_dir, @all_files[number2])
+        if @input[2][0] == "#"
+          if File.exists? file_id_1
+            if File.exists? file_id_2
+              FileUtils.mv(file_id_1, file_id_2)
+            else
+              puts "Incorrect paths"
+              command()
+            end
+          else
+            puts "Incorrect paths"
+            command()
+          end
+        else
+        
+        end
+      end
+      if File.exists? file_1
+        if File.exists? file_2
+          FileUtils.mv(file_1, file_2)
+          command()
+        else
+          puts "Incorrect paths"
+          command()
+        end
+      else
+        puts "Incorrect paths"
+        command()
+      end
+    else
+      puts "No target selected"
+      command()
+    end
+  end
+  
+  # This method is called if the grab method is used with ID instead of file/folder name
+  def grab_id()
+    i = 0
+    this_count = @input.count - 1
+    puts this_count
+    if this_count > 1
+      if @grab_array.count + this_count < attic_c.grab_count+1
+        o = 0
+        while o < this_count do
+          @file_ids.each do |f|
+            if @input[o+1] == "##{f}"
+              o += 1
+              grab_file = File.join(@the_dir, @all_files[f])
+              check_file(grab_file)
+              puts "Adding #{grab_file} to array"
+              @grab_array << grab_file
+              i = 0
+              @grab_num += 1
+              if @grab_num == attic_c.grab_count && attic_c.grab_exit == true && o == this_count
+
+              elsif o == this_count && attic_c.grab_exit == nil
+                command()
+              end
+            end
+            if i == @file_ids.count
+              puts attic_c.grab_not_found
+              if o == this_count
+                command()
+              end
+            end
+            i += 1
+          end
+        end
+      else
+        puts attic_c.grab_full
+        command()
+      end
+    elsif @grab_array.count + 1 < attic_c.grab_count+1
+      @file_ids.each do |f|
+        if @input[1] == "##{f}"
+          grab_file = File.join(@the_dir, @all_files[f])
+          check_file(grab_file)
+          puts "Adding #{grab_file} to array"
+          @grab_array << grab_file
+          @grab_num += 1
+          if @grab_num == attic_c.grab_count && attic_c.grab_exit == true
+          else
+            command()
+          end
+          break
+        end
+        if i+1 == @file_ids.count
+          puts attic_c.grab_not_found
+          command()
+        end
+        i += 1
+      end
+    else
+      puts attic_c.grab_full
+      command()
+    end
+  end
+  
+  # This method is called if the grab method is used with file/folder name instead of ID
+  def grabfile_name
+    if @input[2] != nil
+      the_count = @input.count-1
+      if the_count + @grab_array.count < attic_c.grab_count+1
+        i = 1
+        puts @input.count
+        while i < the_count+1
+          grab_file = File.join(@the_dir, @input[i])
+          check_file(grab_file)
+          @grab_array << grab_file
+          puts "Adding #{grab_file} to array"
+          if i == the_count
+            if attic_c.grab_exit == true
+            else
+              command()
+            end
+          end
+          i += 1
+        end
+      else
+        puts attic_c.grab_full
+        command()
+      end
+    else
+      if @grab_array.count != attic_c.grab_count
+        check_file(@grab_file)
+        @grab_array << @grab_file
+        puts "Adding #{@grab_file} to array"
+        if attic_c.grab_count != true
+          @grab_num += 1
+        end
+      else
+        puts attic_c.grab_full
+        command()
+      end
+    end
+  end
+  
+  # The grab method, to grab select files.
+  # A user can select multiple files at once.
+  def grabfile
+    if attic_c.grab == true && @input[1] != nil
+      @grab_file = File.join(@the_dir, @input[1])
+      if @input[1] == "--help"
+        puts "grab help"
+      else
+        if attic_c.file_id == true && @input[1][0] == "#"
+          grab_id()
+        else
+          if attic_c.grab_count == true
+            grabfile_name()
+          elsif @grab_num != attic_c.grab_count
+            grabfile_name()
+            if @grab_num == attic_c.grab_count && attic_c.grab_exit == true
+              flush()
+            else
+              command()
+            end
+          else
+            if @grab_num == attic_c.grab_count && attic_c.grab_exit == true
+              flush()
+            else
+              puts attic_c.grab_full
+              command()
+            end
+          end
+        end
+      end
+    elsif @input[1] == nil
+      puts attic_c.grab_no_file
+      command()
+    else
+      invalid()
+    end
+  end
+  
+  # Checks if the input is valid for submitting with the selected options
+  # If it is not valid the user will be redirected back to input
+  def submit
+    if attic_c.submit == true
+      if @input[0] == attic_c.submit_command
+        if attic_c.no_blank == true && @input[1] == nil
+          puts attic_c.no_blank_error
+          command()
+        else
+          @input.delete_at(0)
+          flush()
+        end
+      else
+        puts "Invalid command, type '#{attic_c.submit_command} [your text]' to submit"
+        command()
+      end
+    else
+      if attic_c.no_blank == true && @input[0] == nil
+        puts attic_c.no_blank_error
+        command()
+      end
+    end
+  end
+  
+  # Simple error message
+  def invalid
+    puts "Invalid command '#{@input[0]}'"
+    command()
+  end
+  
+  ############################################
+  #           AtticInput functions           #
+  ############################################
+  
+  # The output is converted from array to a string
+  def output
+    @input.map { |i| i.to_s }.join(" ")
+  end
+
+  # The output as an array
+  def array
+    @input_array
+  end
+  
+  # The output counted
+  def count
+    @input.count
+  end
+  
+  # All the files that were grabbed in an array
+  def grab
+    @grab_array
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: attic-path
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kevin van Rooijen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fileutils
+  requirement: &70219838787400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70219838787400
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: &70219838786500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70219838786500
+description: 
+email: attichacker@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/attic-path.rb
+- lib/attic-path/attic_path_commands.rb
+- lib/attic-path/attic_path_input.rb
+homepage: http://rubygems.org/gems/attic-path
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Attic Path is a gem that gives you more options for gets.chomp. With Attic
+  Path you can browse your system while being in the gets.chomp. The user can select
+  files and add them into an array.
+test_files: []