ruby-beautify 0.9.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.orig
+*.pyc

data/README.md

@@ -0,0 +1,5 @@
+About
+=====
+This is a CLI bin to help print pretty ruby text to console.
+
+This is a modifitcation of the sublime-text2 plugin provided by https://github.com/CraigWilliams/BeautifyRuby/blob/master/lib/rbeautify.rb

data/bin/rbeautify

@@ -0,0 +1,29 @@
+#!/usr/bin/ruby
+require 'rbeautify'
+require 'app'
+require 'cli'
+require 'filemagic'
+
+include ErnieBrodeur
+
+App.version = "0.9.0"
+App.banner = "Usage: print ruby into a pretty format, or break trying."
+
+Options.parse!
+
+if ARGV.empty?
+	begin
+		puts RBeautify.beautify_string :ruby, STDIN
+	rescue Exception => e
+		puts e.message
+		exit
+	end
+else
+	ARGV.each do |f|
+		if File.exist? f
+			puts RBeautify.beautify_string :ruby, open(f).read
+		else
+			puts "No such file: #{f}"
+		end
+	end
+end

data/lib/app.rb

@@ -0,0 +1,79 @@
+$:.push '/home/ebrodeur/Projects/bin_snippets/lib'
+
+# Some requires, they don't fit elsewhere.
+require 'yajl'
+require 'sys/proctable'
+module ErnieBrodeur
+
+  class Application
+    attr_accessor :version
+    attr_accessor :banner
+    attr_accessor :long_description
+    attr_accessor :plugins
+
+    # return the name of the app, for now this is just the cmd ran, later it will be
+    # something generated but more unique.
+    def name
+      $0.split("/").last
+    end
+
+    def cache_dir
+      "#{Dir.home}/.cache/erniebrodeur/#{App.name}/"
+    end
+
+    def config_dir
+      "#{Dir.home}/.config/erniebrodeur/#{App.name}/"
+    end
+
+    def pids
+      a = Sys::ProcTable.ps.select{|x| x.cmdline =~ /.*#{App.name}.*-[dD].*/}.map {|x| x.pid}
+      a.delete $$
+      return a if a.any?
+      nil
+    end
+
+    def initialize
+      @version = '0.0.0'
+      @banner  = 'A bin snippet by Ernie Brodeur that does . . . something.'
+      @long_description = ''
+      @plugins = []
+    end
+
+    def daemonize(*params, &block)
+      if params[0] && !params[0][:multiple_pids] && pids
+        puts_or_log :info, "#{App.name} appears to be running (#{pids}), only one allowed, exiting."
+        exit
+      end
+      puts_or_log :info, "Forking to background."
+
+      Process.daemon
+      block.call
+    end
+
+    def kill_daemon
+      if !pids
+        puts_or_log :fatal, "No pids found, exiting."
+      end
+
+      pids.each do |p|
+        puts_or_log :info, "Killing #{p}"
+        %x[kill -TERM #{p}]
+           end
+           end
+           private
+           def puts_or_log(l, s)
+             if App.plugins.include? 'logging'
+               Log.send l, s
+             else
+               puts s
+               exit if l.to_sym == :fatal
+             end
+           end
+           end
+
+           App = Application.new
+
+           # This will load a helper, if it exists.
+           f = "#{$:.last}/helpers/#{App.name}.rb"
+           require f if File.exist? f
+           end

data/lib/beautifier.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+# Ruby beautifier, version 2.1, 09/11/2006
+# Copyright (c) 2006, P. Lutus
+# Released under the GPL
+
+# Changes
+# Craig Williams
+# 12/26/2011
+# Modified (very minor) to work with a Sublime Text 2 plugin
+
+# indent regexp tests
+
+@indentExp = [
+  /^module\b/,
+  /^if\b/,
+  /^\@{0,2}[\w\.]*[\s\t]*\=[\s\t]*if\b/,
+  /(=\s*|^)until\b/,
+  /(=\s*|^)for\b/,
+  /^unless\b/,
+  /^\@{0,2}[\w\.]*[\s\t]*\=[\s\t]*unless\b/,
+  /(=\s*|^)while\b/,
+  /(=\s*|^)begin\b/,
+  /(^| )case\b/,
+  /\bthen\b/,
+  /^class\b/,
+  /^rescue\b/,
+  /^def\b/,
+  /\bdo\b/,
+  /^else\b/,
+  /^elsif\b/,
+  /^ensure\b/,
+  /\bwhen\b/,
+  /\{[^\}]*$/,
+  /\[[^\]]*$/,
+  /\([^\)]*$/
+]
+
+# outdent regexp tests
+
+@outdentExp = [
+  /^rescue\b/,
+  /^ensure\b/,
+  /^elsif\b/,
+  /^end\b/,
+  /^else\b/,
+  /\bwhen\b/,
+  /^[^\{]*\}/,
+  /^[^\[]*\]/,
+  /^[^\(]*\)/
+]
+
+def makeTab(tab)
+  (tab < 0) ? "" : @tabStr * @tabSize * tab
+end
+
+def addLine(line,tab)
+  line.strip!
+  line = makeTab(tab)+line if line.length > 0
+  line + "\n"
+end
+
+def beautifyRuby(contents)
+  commentBlock = false
+  programEnd = false
+  multiLineArray = Array.new
+  multiLineStr = ""
+  tab = 0
+  source = contents
+  dest = ""
+  source.split("\n").each do |line|
+    if(!programEnd)
+      # detect program end mark
+      if(line =~ /^__END__$/)
+        programEnd = true
+      else
+        # combine continuing lines
+        if(!(line =~ /^\s*#/) && line =~ /[^\\]\\\s*$/)
+          multiLineArray.push line
+          multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
+          next
+        end
+
+        # add final line
+        if(multiLineStr.length > 0)
+          multiLineArray.push line
+          multiLineStr += line.sub(/^(.*)\\\s*$/,"\\1")
+        end
+
+        tline = ((multiLineStr.length > 0)?multiLineStr:line).strip
+        if(tline =~ /^=begin/)
+          commentBlock = true
+        end
+      end
+    end
+    if(commentBlock || programEnd)
+      # add the line unchanged
+      dest += line + "\n"
+    else
+      commentLine = (tline =~ /^#/)
+      if(!commentLine)
+        # throw out sequences that will
+        # only sow confusion
+        while tline.gsub!(/'.*?'/,"")
+        end
+        while tline.gsub!(/".*?"/,"")
+        end
+        while tline.gsub!(/\`.*?\`/,"")
+        end
+        while tline.gsub!(/\{[^\{]*?\}/,"")
+        end
+        while tline.gsub!(/\([^\(]*?\)/,"")
+        end
+        while tline.gsub!(/\/.*?\//,"")
+        end
+        while tline.gsub!(/%r(.).*?\1/,"")
+        end
+        tline.gsub!(/\\\"/,"'")
+        @outdentExp.each do |re|
+          if(tline =~ re)
+            tab -= 1
+            break
+          end
+        end
+      end
+      if (multiLineArray.length > 0)
+        multiLineArray.each do |ml|
+          dest += addLine(ml,tab)
+        end
+        multiLineArray.clear
+        multiLineStr = ""
+      else
+        dest += addLine(line,tab)
+      end
+      if(!commentLine)
+        @indentExp.each do |re|
+          if(tline =~ re && !(tline =~ /\s+end\s*$/))
+            tab += 1
+            break
+          end
+        end
+      end
+    end
+    if(tline =~ /^=end/)
+      commentBlock = false
+    end
+  end
+  STDOUT.write(dest)
+  # uncomment this to complain about mismatched blocks
+  # if(tab != 0)
+  #   STDERR.puts "#{path}: Indentation error: #{tab}"
+  # end
+end
+
+tab_or_space = ARGV.first
+path         = ARGV.last
+path.gsub!("\\", "/") if RUBY_PLATFORM =~ /mswin/
+contents     = IO.read(path)
+
+if tab_or_space == 'space'
+  @tabSize = 2
+  @tabStr = " "
+else
+  @tabSize = 1
+  @tabStr = "\t"
+end
+
+beautifyRuby(contents)

data/lib/cli.rb

@@ -0,0 +1,81 @@
+# This library is to reduce the amount of effort I need to build a binary with option parsing
+# and sensable defaults.  It is not intended to be convient for anybody but me, their
+# are a host of good @options out there if you want cli tools.
+require 'optparse'
+
+module ErnieBrodeur
+  class OptBlob
+    def initialize
+      @options = {}
+
+      @parser = OptionParser.new do |opts|
+        opts.banner = ErnieBrodeur::App.banner
+
+        opts.on("-V", "--version", "Print version") { |version| @options[:version] = true}
+        opts.on("-p", "--pry", "open a pry shell.") { |pry| @options[:pry] = true}
+        if App.plugins.include? 'logging'
+          opts.on("-l", "--log-level LEVEL", "Change the log level, default is debug.") { |level| ErnieBrodeur::Log.level level }
+          opts.on("--log-file FILE", "What file to output to, default is STDOUT") { |file| ErnieBrodeur::Log.filename file }
+        end
+      end
+    end
+
+    #TODO figure out a more dynamic way to include the parser and hash table.
+    def []=(key, value)
+      @options[key] = value
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    # This will build an on/off option with a default value set to false.
+    def bool_on(word, description = "")
+      Options[word.to_sym] = false
+      @parser.on "-#{word.chars.first}", "--[no]#{word}", description  do |o|
+        Options[word.to_sym] == o
+      end
+    end
+
+    # This is the parser value on lifted up.
+    def on(*opts, &block)
+      @parser.on(*opts, &block)
+    end
+
+    def on_tail(*opts, &block)
+      @parser.on(*opts, &block)
+    end
+
+    def on_head(*opts, &block)
+      @parser.on(*opts, &block)
+    end
+
+    def parse!
+      @parser.banner = ErnieBrodeur::App.banner
+      @parser.parse!
+
+      if @options[:version]
+        puts ErnieBrodeur::App.version
+        exit 0
+      end
+
+      # we need to mash in our config array.  To do this we want to make config
+      # options that don't overwrite cli options.
+      if App.plugins.include? 'config'
+        Config.each do |k,v|
+          @options[k] = v if !@options[k]
+        end
+      end
+    end
+
+    def on_pry
+      if @options[:pry]
+        require 'pry'
+        binding.pry
+      end
+    end
+  end
+
+  App.plugins.push "cli"
+  Options = OptBlob.new
+end

data/lib/filemagic.rb

@@ -0,0 +1,13 @@
+module ErnieBrodeur
+  # Add some basic filemagic types.
+  class FileMagic
+    def self.mime_type(file)
+      if File.exist? file
+        %x[file -bk --mime-type '#{file}'].chomp!
+      else
+        raise 'nosuchfile'
+      end
+    end
+  end
+  App.plugins.push 'filemagic'
+end

data/lib/rbeautify.rb

@@ -0,0 +1,27 @@
+require 'rbeautify/block_start'
+require 'rbeautify/block_end'
+require 'rbeautify/block_matcher'
+require 'rbeautify/language'
+require 'rbeautify/line'
+
+require 'rbeautify/config/ruby'
+
+module RBeautify
+
+  def self.beautify_string(language, source, use_tabs=false)
+    dest = ""
+    block = nil
+
+    unless language.is_a? RBeautify::Language
+      language = RBeautify::Language.language(language)
+    end
+
+    source.lines.each_with_index do |line_content, line_number|
+      line = RBeautify::Line.new(language, line_content, line_number, block, use_tabs)
+      dest += line.format + "\n"
+      block = line.block
+    end
+
+    return dest
+  end
+end # module RBeautify

data/lib/rbeautify/block_end.rb

@@ -0,0 +1,23 @@
+module RBeautify
+
+  class BlockEnd
+
+    attr_accessor :block_start, :offset, :match, :after_match
+
+    def initialize(block_start, offset, match, after_match)
+      self.block_start = block_start
+      self.offset = offset
+      self.match = match
+      self.after_match = after_match
+    end
+
+    def end_offset
+      offset + match.length
+    end
+
+    def end_can_also_be_start?
+      block_start.block_matcher.end_can_also_be_start?
+    end
+  end
+
+end

data/lib/rbeautify/block_matcher.rb

@@ -0,0 +1,153 @@
+module RBeautify
+
+  class BlockMatcher
+
+    attr_reader :language, :name, :starts, :ends, :options
+
+    def initialize(language, name, starts, ends, options = {})
+      @language = language
+      @name = name
+      @starts = starts
+      @ends = ends.nil? ? starts : ends
+      @options = options
+    end
+
+    class << self
+      def parse(language, original_block, line_number, string, current_offset)
+        block_end = original_block && original_block.parse_block_end(string, current_offset)
+
+        if (block_start = first_block_start(language,
+                                            original_block,
+                                            line_number,
+                                            string,
+                                            current_offset,
+                                            block_end.nil? ? nil : block_end.offset))
+
+          block_end = nil
+        end
+
+        if block_end
+          # Check whether the section of the line which is a block end is also a block start
+          if block_end.end_can_also_be_start? &&
+              (block_start_candidate = first_block_start(language, block_end.block_start.parent, line_number, string, current_offset)) &&
+              block_start_candidate.offset == block_end.offset
+            block_start = block_start_candidate
+          end
+
+        end
+
+        if block_start
+          if debug
+            puts "MATCH: '#{string.slice(0, string.length - block_start.match.length - block_start.after_match.length)}<START type=#{block_start.name}>#{block_start.match}</START>#{block_start.after_match}'"
+          end
+          parse(language, block_start, line_number, block_start.after_match, block_start.end_offset)
+        elsif block_end
+          if debug
+            puts "MATCH: '#{string.slice(0, string.length - block_end.match.length - block_end.after_match.length)}<END>#{block_end.match}</END>#{block_end.after_match}'"
+          end
+          parse(language, block_end.block_start.parent, line_number, block_end.after_match, block_end.end_offset)
+        else
+          original_block
+        end
+      end
+
+      def debug=(value)
+        @debug = value
+      end
+
+      def debug
+        @debug
+      end
+
+      private
+        def first_block_start(language, parent_block, line_number, string, offset, maximum_offset = nil)
+          first_block_start = nil
+          language.matchers.each do |matcher|
+            if matcher.can_nest?(parent_block)
+              if (block_start_candidate = matcher.parse_block_start(string, parent_block, offset, line_number)) &&
+                  (maximum_offset.nil? || maximum_offset > block_start_candidate.offset)
+                first_block_start = block_start_candidate
+                maximum_offset = first_block_start.offset
+              end
+            end
+          end
+          first_block_start
+        end
+    end
+
+    def parse_block_start(string, parent_block, offset, line_number)
+      if !string.empty? && (match = starts.match(string))
+        RBeautify::BlockStart.new(self, parent_block, line_number, offset + match.begin(0), match[0], match.post_match)
+      end
+    end
+
+    def indent_end_line?(block)
+      evaluate_option_for_block(:indent_end_line, block)
+    end
+
+    def indent_size(block)
+      evaluate_option_for_block(:indent_size, block) || language.indent_size
+    end
+
+    # Look for blocks within the content of this one
+    def parse_content?
+      options[:parse_content] != false
+    end
+
+    # Indent the content of this block
+    def format_content?
+      options[:format_content] != false
+    end
+
+    def can_nest?(parent_block)
+      return false unless parent_block.nil? || parent_block.parse_content?
+
+      if options[:nest_only]
+        parent_block && options[:nest_only].include?(parent_block.name)
+      else
+        parent_block.nil? ||
+          options[:nest_except].nil? || !options[:nest_except].include?(parent_block.name)
+      end
+    end
+
+    def ends?
+      ends != false
+    end
+
+    def end_is_implicit?
+      options[:end] == :implicit
+    end
+
+    def end_can_also_be_start?
+      if ends == starts
+        options[:end_can_also_be_start] == true
+      else
+        options[:end_can_also_be_start] != false
+      end
+    end
+
+    def negate_ends_match?
+      options[:negate_ends_match]
+    end
+
+    # True if blocks can contain the escape character \ which needs to be
+    # checked for on end match
+    def escape_character?
+      options[:escape_character] == true
+    end
+
+    def inspect
+      name
+    end
+
+    private
+      def evaluate_option_for_block(key, block)
+        if options[key] && options[key].respond_to?(:call)
+          options[key].call(block)
+        else
+          options[key]
+        end
+      end
+
+  end
+end