startor 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 998bba49132f5d6805135b181e5ce13cbc00555318f7c3e164c949527dc103df
+  data.tar.gz: 58b182ce0395000d88a10ee09bbe251f9be5af668f8ed1f905e5a147d74066ee
+SHA512:
+  metadata.gz: 68e883397b9a44f78a1b8ab0717652b3a686767a8ce5473dfb1e0f2fabd33bba7749862516402db8215feb9f7ad00cdb98db4bff5f8b521feb5e1004e1aee387
+  data.tar.gz: 7c9ed15bfa22c96dd580bd6420836a0a7b41f5fac1dbaef41ae37835c25745a6642f2950df8394bfdc8a0321ed915d9977c485ff3af5e2cbc8f9a57324ca620d

data/bin/startor

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+# startor
+
+# 20181106
+# 0.6.0
+
+# History: Derived from https://kremalicious.com/simple-tor-setup-on-mac-os-x/...
+
+# Prerequisites:
+# 1. tor binary is installed.
+# 2. Ruby is installed, which it should be already!
+
+# Installation:
+# 1. Press the <cmd> and <space> keys on the keyboard simultaneously.
+# 2. Type: "Terminal.app" and press the <return> key.
+# 3. Type: "gem install startor"
+
+# How to use:
+# 1. Press the <cmd> and <space> keys on the keyboard simultaneously.
+# 2. Type: "Terminal.app" and press the <return> key.
+# 3. Type: "startor setup" and press the <return> key.
+# 4. Type: "startor" and press the <return> key.
+# 5. If prompted, enter the password you use to login to your computer.
+# 6. When wanting stop tor, go to the same window as the commands immediately above were entered and press the <ctrl> and <c> keys on the keyboard simultaneously.
+# 7. If prompted, enter the password you use to login to your computer.
+
+# Notes:
+# 1. The hardware ports can be any of: 'Thunderbolt Ethernet', 'Thunderbolt Bridge', 'Wi-Fi', 'Ethernet', 'Bluetooth PAN', or 'Display Ethernet'.
+# 2. See `networksetup -listallnetworkservices` for the complete list of hardware ports on your machine.
+
+# Todo: (one or more of the following, in no particular order)
+# 1. Turn this into a gem.  Done as of 0.6.0.
+# 2. Turn this into a brew formula.
+# 3. Remove some of the comments here and put those into a README or INSTALL or other files as appropriate.
+# 4. Create a(n) .app out of this by using some simple wrapper code.
+# 5. Make it cross-platform: OSX, Linux, and Windows, at least.
+# 6. Clean up the required libraries so that they are either gemified and/or reduced in number.
+
+# Changes:
+# Gemification and further tidying...
+# 1. + startor.gemspec
+# 2. Added to the section of comments entitled "Installation", which includes making use of the startor gem.
+
+require 'FileUtils/which'
+require 'Kernel/run'
+require 'OSX/HardwarePort'
+require 'OSX/IfConfig'
+
+def install_homebrew
+  if FileUtils.which('brew')
+    puts 'Homebrew is already installed!'
+  else
+    run('/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"', show: true)
+  end
+end
+
+def install_tor
+  if FileUtils.which('tor')
+    puts 'tor is already installed!'
+  else
+    run('brew install tor', show: true)
+  end
+end
+
+def setup
+  install_homebrew
+  install_tor
+end
+
+def tor_installed?
+  FileUtils.which('tor')
+end
+
+def check_for_tor_program
+  unless tor_installed?
+    puts "tor was not found.  You must install tor first."
+    puts "The easist way to install it is by running `startor setup`."
+    exit
+  end
+end
+
+def enter_admin_password
+  system('sudo -v')
+end
+
+def active_network_interfaces
+  OSX::IfConfig.new.active_interfaces
+end
+
+def active_network_ports
+  active_network_interfaces.collect do |active_network_interface|
+    if hardware_port = OSX::HardwarePort.find_by_device(active_network_interface)
+      hardware_port.name
+    end
+  end.compact
+end
+
+def setup_interfaces
+  active_network_ports.each do |active_network_port|
+    run("sudo networksetup -setsocksfirewallproxy '#{active_network_port}' 127.0.0.1 9050 off", show: true)
+  end
+end
+
+def puts_with_colour(string, colour)
+  system("echo \"$(tput setaf #{colour})\"")
+  puts string
+  system('echo "$(tput sgr0)"') # color reset
+end
+
+def puts_green(string)
+  puts_with_colour(string, 64) # Set console text colour to green(ish).
+end
+
+def puts_orange(string)
+  puts_with_colour(string, 136) # Set console text colour to orange.
+end
+
+def enable_proxy
+  active_network_ports.each do |active_network_port|
+    run("sudo networksetup -setsocksfirewallproxystate '#{active_network_port}' on", show: true)
+    puts_green('SOCKS proxy 127.0.0.1:9050 enabled.')
+    puts_orange('Starting Tor...')
+  end
+end
+
+def system_tor
+  system('tor')
+end
+
+def exec_tor
+  exec('tor')
+end
+
+def disable_proxy
+  active_network_ports.each do |active_network_port|
+    run("sudo networksetup -setsocksfirewallproxystate '#{active_network_port}' off", show: true)
+    puts_green('SOCKS proxy disabled.')
+  end
+end
+
+def common_up
+  check_for_tor_program
+  enter_admin_password
+  setup_interfaces
+  enable_proxy
+end
+
+def explicit_up
+  common_up
+  exec_tor
+end
+
+def implicit_up
+  common_up
+  system_tor
+end
+
+def down
+  disable_proxy
+end
+
+def main
+  case ARGV[0]
+  when 'up'; explicit_up
+  when 'down'; down
+  when 'setup'; setup
+  else; implicit_up
+  end
+rescue SystemExit, Interrupt
+  down if tor_installed?
+end
+
+main

data/lib/Array/all_but_last.rb

@@ -0,0 +1,24 @@
+# Array#all_but_last
+
+# 20080831
+# 0.1.0
+
+# Description: This returns a copy of the receiving array with the last element removed.  
+
+# Changes since 0.0: 
+# 1. I've added require 'Array/lastX', since I think it is reasonable that each file should load its own dependencies.  
+
+# Todo: 
+# 1. Conditionally do the require depending on whether the method already exists on Array and/or on whether rubylib has been defined elsewhere, since the require will fail in either case; and if rubylib is available, but this method isn't.  
+
+require 'Array/lastX'
+
+class Array
+  
+  def all_but_last
+    d = self.dup
+    d.last!
+    d
+  end
+  
+end

data/lib/Array/extract_optionsX.rb

@@ -0,0 +1,21 @@
+# Array/extract_optionsX.rb
+# Array#extract_options!
+
+# 20140402
+# 0.1.1
+
+# History: Stolen wholesale from ActiveSupport.
+
+# Changes:
+# 1. + #extract_options (no exclamation).  Whereas I had previously had #extract_options mean the same as what I now call #peek_options, I decided that Array has some precedents for method names which do not have a bang method, but which do modify the receiver in place; #shift, #unshift, #push, and #pop come to mind...
+# 0/1
+# 2. Some minor tidying.
+
+class Array
+
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+  alias_method :extract_options, :extract_options!
+
+end

data/lib/Array/lastX.rb

@@ -0,0 +1,10 @@
+# Array#last!
+# 20060630
+#
+# Description: Sometimes it makes more sense to treat arrays this way.  
+#
+# Discussion: This and first! were taken from Skink2Quick from a few months ago.  
+
+class Array
+  alias_method :last!, :pop
+end

data/lib/File/basename_without_extname.rb

@@ -0,0 +1,17 @@
+# File#basename_without_extname
+# File/basename_without_extname
+
+# 2010.06.05
+# 0.0.0
+
+# Description: This returns the basename without the extension for a given File instance without the need to specify what the extension is because it makes use of File.extension which works that out.  
+
+require 'File/extname'
+
+class File
+  
+  def basename_without_extname
+    File.basename(path, extname)
+  end
+  
+end

data/lib/File/extname.rb

@@ -0,0 +1,18 @@
+# File/extname.rb
+# File#extname
+
+# 20140412
+# 0.2.0
+
+# Description: This is the instance method version of the class method on File by the same name.
+
+# Changes since 0.1:
+# 1. Using the built-in class-method now.
+
+class File
+
+  def extname
+    File.extname(path)
+  end
+
+end

data/lib/File/self.gsubX.rb

@@ -0,0 +1,54 @@
+# File/self.gsubX
+# File.gsub!
+
+# 20111122
+# 0.0.1
+
+# Description: This takes a file and replaces any text it finds according to a regular expression with a supplied string.  
+
+# History: 
+# 1. Separated class and instance methods to their own files at File#gsubX 0.3.6/0.4.  
+
+# Changes: 
+# 1. /File.gsubX/File\/self.gsubX/.  
+
+class File
+  
+  def self.gsub!(filename, replacement_pattern, replacement_text, selection_pattern = nil)
+    replacement_pattern = (
+      case replacement_pattern
+      when String; Regexp.new(Regexp.escape(replacement_pattern))
+      when Regexp; replacement_pattern
+      else; raise
+      end
+    )
+    selection_pattern = replacement_pattern unless selection_pattern
+    selection_pattern = (
+      case selection_pattern
+      when String; Regexp.new(Regexp.escape(selection_pattern))
+      when Regexp; selection_pattern
+      else; raise
+      end
+    )
+    file_handle = self.open(filename, 'r')
+    tmp_file_handle = self.new(filename + '.tmp', 'w')
+    modified = false
+    file_handle.each do |line|
+      if line =~ Regexp.new(selection_pattern)
+        tmp_file_handle.print line.gsub(Regexp.new(replacement_pattern), replacement_text)
+        modified = true
+      else
+        tmp_file_handle.print line
+      end
+    end
+    file_handle.close
+    tmp_file_handle.close
+    if modified
+      self.delete(filename)
+      self.rename(filename + '.tmp', filename)
+    else
+      self.delete(filename + '.tmp')
+    end
+  end
+  
+end

data/lib/FileUtils/where.rb

@@ -0,0 +1,37 @@
+# FileUtils/where.rb
+# FileUtils#where
+
+# 20140912
+# 0.0.2
+
+# History: Derived from where 0.2.3---the original command version I wrote in Ruby.
+
+# Changes:
+# 1. Removed trailing spaces.
+# 2. - require 'File/extension', since it doesn't seem to be being used.
+# 3. /require 'File/basename_without_extension'/require 'File/basename_without_extname'/, and uses thereof.
+# 4. /require 'Platform/windowsQ'/require 'Platform/OS', and use thereof.
+
+require 'File/basename_without_extname'
+require 'Platform/OS'
+
+module FileUtils
+
+  def where(executable_sought)
+    paths = ENV['PATH'].split(/:/)
+    sought_paths = []
+    paths.uniq.each do |path|
+      Dir["#{path}/*"].each do |executable|
+        if Platform::OS.windows?
+          sought_paths << executable if File.basename_without_extname(executable) == File.basename_without_extname(executable_sought)
+        else
+          sought_paths << executable if File.basename(executable) == executable_sought
+        end
+      end
+    end
+    sought_paths.empty? ? nil : sought_paths
+  end
+
+  module_function :where
+
+end

data/lib/FileUtils/which.rb

@@ -0,0 +1,20 @@
+# FileUtils#which
+
+# 20100320
+# 0.0.0
+
+require 'FileUtils/where'
+
+module FileUtils
+  
+  def which(executable_sought)
+    if where_results = FileUtils.where(executable_sought)
+      where_results[0]
+    else
+      nil
+    end
+  end
+  
+  module_function :which
+  
+end

data/lib/Files.rb

@@ -0,0 +1,249 @@
+# Files.rb
+# Files
+
+# 20140508
+# 0.8.3
+
+# Changes since 0.7: (Switched from using Files to OpenStructs for @files instance variable because Ruby can't open more than some hundreds of files and nil was being returned after that limit had been reached.)
+# 1. - Files.files_for().
+# 2. + Files.with_attributes().
+# 3. /return_files_object/return_ostruct_object/.
+# 4. ~ Files.in_path___with_pattern___(), so as to make reference to Files.with_attributes().
+# 5. ~ Files#absolute_paths(), to not rely upon an extension to File.
+# 6. ~ Files#dirnames(), to not rely upon an extension to File.
+# 7. ~ Files#absolute_dirnames(), to not rely upon an extension to File.
+# 8 - require_relative './File'.
+# 0/1
+# 9. Even though MacRuby is supposed to be an MRI 1.9.2 analogue, it doesn't know Kernel#require_relative, so I've added a 'backport' for it in Ruby.
+# 1/2
+# 10. I don't need require_relative if I am altering the path and wrapping this up as a gem does that automatically for me.
+# 11. However, perhaps I can't assume that someone will be using RubyGems, so I've got some $LOAD_PATH manipulation stuff there instead.  It also means that I don't have to change any of the test code, else I'd have to it in there.  Perhaps it doesn't matter terribly which of these ways I do this?
+# 12. - ruby '1.9.3' from the Gemfile, since I had merely copied and pasted that from another project.
+# 2/3
+# 13. /MiniTest::Unit::TestCase/MiniTest::Test/.
+# 14. + gem 'minitest' to all children test files and to the Gemfile so as to silence the warnings.
+# 15. Moved test/all.rb to test/Files.rb.
+# 16. Moved all children tests to test/Files/ as was forshadowed by the first line of the test files prior to 8.3.
+# 17. ~ TC_Files_instance_methods_performing_operations#test_gsub! and #test_move, so that they were actually testing the instance methods and not the class methods as they were, thereby helping improve test coverage to 99.07%.
+# 18. + TC_Files_instance_methods#test_initialize_with_no_filenames_and_no_path_or_pattern, so as to achieve 100% test coverage finally.
+# 19. /TC_Files_instance_methods#test_initialize_with_no_path_or_pattern/TC_Files_instance_methods#test_initialize_with_a_filename/, so as to make the name more accurate.
+# 20. /TC_Files_instance_methods#test_initialize_and_a_path/TC_Files_instance_methods#test_initialize_with_a_path/, so as to make the name more accurate.
+# 21. /TC_Files_instance_methods#test_initialize_and_a_pattern/TC_Files_instance_methods#test_initialize_with_a_pattern/, so as to make the name more accurate.
+# 22. /TC_Files_instance_methods#test_initialize_and_a_path_and_pattern/TC_Files_instance_methods#test_initialize_with_a_path_and_pattern/, so as to make the name more accurate.
+# 23. Updated lib/Array/extract_optionsX.rb to the latest version.
+# 24. Added lib/Array/all_but_last.rb, since it was a missing dependency.
+# 25. Added lib/Array/lastX.rb, since it too was a missing dependency.
+# 26. ~ Files#sort_method_macro, #sorter_macro, and #reverse_sort_method_macro, so as to make use of instance_eval rather than eval.
+# 27. Added Kernel/require_relative.rb back, since I should be able to run the specs with MacRuby as well.
+# 28. Updated the gemspec with latest version number.
+
+# Todo:
+# 1. Ensure that the interface is sufficiently usable that it will be reading for a 1.0 release after some more tinkering through the remainder of 0.8 and 0.9.
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless
+  $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'Array/extract_optionsX'
+require 'File/self.gsubX'
+require 'fileutils'
+require 'Module/alias_methods'
+require 'ostruct'
+
+class Files
+
+  class << self
+
+    def find(options = {})
+      path, pattern, return_ostruct_object = options[:path], options[:pattern], options[:return_ostruct_object]
+      case
+      when path && pattern
+        in_path___with_pattern___(path, pattern, return_ostruct_object)
+      when path && !pattern
+        in_path___(path, return_ostruct_object)
+      when !path && pattern
+        with_pattern___(pattern, return_ostruct_object)
+      when !path && !pattern
+        here(return_ostruct_object)
+      end
+    end
+    alias_methods :all, :find
+
+    def in_path___with_pattern___(path, pattern, return_ostruct_object = true)
+      files = with_attributes(Dir["#{path}/#{pattern}"])
+      if return_ostruct_object
+        files_object = Files.new
+        files_object.files = files
+        files_object
+      else
+        files
+      end
+    end
+    alias_methods :in_path_matching, :in_path___matching___,
+      :in_path_with_pattern, :in_path___with_pattern___
+
+    def in_path___(path, return_ostruct_object = true)
+      in_path___matching___(path, '*', return_ostruct_object)
+    end
+    alias_methods :in, :in_path, :in_path___
+
+    def with_pattern___(pattern, return_ostruct_object = true)
+      in_path___matching___('./', pattern, return_ostruct_object)
+    end
+    alias_methods :with_pattern, :with_pattern___
+
+    def here(return_ostruct_object = true)
+      in_path___matching___('./', '*', return_ostruct_object)
+    end
+
+    def with_attributes(paths)
+      paths.collect do |path|
+        begin
+          f = {}
+          f[:path] = path
+          f[:size] = File.stat(path).size
+          f[:ftype] = File.stat(path).ftype
+          f[:mode] = File.stat(path).mode
+          f[:gid] = File.stat(path).gid
+          f[:uid] = File.stat(path).uid
+          f[:ctime] = File.stat(path).ctime
+          f[:mtime] = File.stat(path).mtime
+          f[:atime] = File.stat(path).atime
+          OpenStruct.new(f)
+        rescue
+        end
+      end
+    end
+
+    def gsub!(filenames, replacement_pattern, replacement_text, selection_pattern = nil)
+      filenames.each do |filename|
+        File.gsub!(filename, replacement_pattern, replacement_text, selection_pattern)
+      end
+    end
+
+    def move(filenames, replacement_pattern, replacement_text)
+      filenames.each do |filename|
+        new_filename = filename.gsub(/#{replacement_pattern}/, replacement_text)
+        FileUtils.mv(filename, new_filename)
+      end
+    end
+    alias_methods :ren, :rename, :mv, :move
+
+  end # class << self
+
+  include Enumerable
+
+  attr_writer :files
+  attr_reader :path
+  attr_reader :pattern
+
+  def initialize(*args)
+    options = args.extract_options!
+    @args, @path, @pattern = args, options[:path], options[:pattern]
+    load_metaprogrammed_methods
+  end
+
+  def files
+    @files ||= (
+      if !@args.empty?
+        Files.with_attributes(@args.flatten)
+      elsif path && pattern
+        Files.find(path: path, pattern: pattern, return_ostruct_object: false)
+      elsif path
+        Files.find(path: path, return_ostruct_object: false)
+      elsif pattern
+        Files.find(pattern: pattern, return_ostruct_object: false)
+      else
+        []
+      end
+    )
+  end
+
+  def each
+    files.each{|f| yield f}
+  end
+
+  def paths
+    files.collect{|f| f.path}
+  end
+
+  def absolute_paths
+    files.collect{|f| File.expand_path(f.path)}
+  end
+
+  def dirnames
+    files.collect{|f| File.dirname(f.path)}
+  end
+
+  def absolute_dirnames
+    files.collect{|f| File.dirname(File.absolute_path(f.path))}
+  end
+
+  def gsub!(replacement_pattern, replacement_text)
+    Files.gsub!(paths, replacement_pattern, replacement_text)
+  end
+
+  def move(replacement_pattern, replacement_text)
+    Files.move(paths, replacement_pattern, replacement_text)
+  end
+  alias_methods :ren, :rename, :mv, :move
+
+  def path=(new_path)
+    @path = new_path
+    set_files
+  end
+
+  def pattern=(new_pattern)
+    @pattern = new_pattern
+    set_files
+  end
+
+  private
+
+  def set_files
+    @files = nil
+    files
+  end
+
+  def load_metaprogrammed_methods
+    sort_method_macro
+    reverse_sort_method_macro
+    sorter_macro
+  end
+
+  def sort_method_macro
+    %w(atime ctime mtime size ftype mode gid uid filename).each do |method|
+      instance_eval("
+        def sort_by_#{method}
+          files.sort! do |a,b|
+            by_#{method}(a,b)
+          end
+          self
+        end
+      ")
+    end
+  end
+
+  def sorter_macro
+    %w(atime ctime mtime size ftype mode gid uid filename).each do |method|
+      instance_eval("
+        def by_#{method}(a,b)
+          a.#{method} <=> b.#{method}
+        end
+      ")
+    end
+  end
+
+  def reverse_sort_method_macro
+    %w(atime ctime mtime size ftype mode gid uid filename).each do |method|
+      instance_eval("
+        def reverse_sort_by_#{method}
+          files.sort! do |a,b|
+            by_#{method}(a,b)
+          end.reverse!
+          self
+        end
+      ")
+    end
+  end
+
+end

data/lib/Kernel/run.rb

@@ -0,0 +1,43 @@
+# Kernel/run.rb
+# Kernel#run
+
+# 20170613
+# 0.1.5
+
+# Changes:
+# 1. Make use of a number of options, substituting ENV['DRY_RUN'] for options[:dry_run], and adding :show and :dont_raise.
+# 0/1
+# 2. When showing the output make it clear that it is a dry run.
+# 1/2
+# 3. If the :dry_run option is specified, then it makes no sense to test $? for success, so group all that code in the unless.
+# 2/3
+# 4. The logic was reversed for whether to raise or not.
+# 3/4
+# 5. Really fixed the raise logic finally, I think.
+# 4/5
+# 6. Yet another attempt at fixing the raise logic.
+
+# Todo:
+# 1. Even though this is a small method it might be good idea to add some automated tests.
+
+require 'Array/extract_optionsX'
+
+module Kernel
+
+  def run(*args)
+    options = args.extract_options!
+    command = args
+    if options[:show] && !options[:dry_run]
+      puts command.join(' ')
+    elsif options[:show] && options[:dry_run]
+      puts "DRY RUN *** #{command.join(' ')} *** DRY RUN"
+    end
+    unless options[:dry_run]
+      system(*command)
+      if !$?.success? && !options[:dont_raise]
+        raise "#{command.inspect} failed to exit cleanly."
+      end
+    end
+  end
+
+end

data/lib/Module/alias_methods.rb

@@ -0,0 +1,16 @@
+# Module#alias_methods
+
+# 20080831
+# 0.0.0
+
+# Description: I have a penchance for having multiple method names and having line after line of alias_method calls is kinda ugly.  
+
+require 'Array/all_but_last'
+
+class Module
+  
+  def alias_methods(*args)
+    args.all_but_last.each{|e| alias_method e.to_sym, args.last.to_sym}
+  end
+  
+end