eden 0.1.1

data/CHANGELOG

@@ -0,0 +1,4 @@
+0.1.1
+- Fixed banner message displayed when no params passed to eden.
+
+0.1.0 -- Initial Release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jason Langenauer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+# Eden
+
+Eden is a source-code formatter for Ruby. It's designed around a robust lexical analyzer able to handle
+most of the dark corners of Ruby syntax, and able to be easily modified and extended.
+
+## Installation
+
+Eden is available as a gem. To install it, simply run:
+
+    gem install eden
+
+## Configuration
+
+Eden's formatter modules are able to be configured using a Ruby configuration DSL. Eden loads defaults when it
+starts, but if you wish to override options on a project-specific basis, you can do so by creating
+a file `config/eden.rb`. For example, if you wish to use tabs instead of spaces to indent a project's code, put
+the following in `config/eden.rb`:
+
+    Indenter.configure do |i|
+      i.indent_characters_per_step 1
+      i.indent_character "\t"
+    end
+
+Refer to `lib/eden/defaults.rb` for full configuration options.
+
+## Using Eden
+
+Eden is designed to be used with a source-control system, so when it formats Ruby source files, it writes changes
+to the file in place. The basic format for running Eden is:
+
+    eden command filenames
+
+Eden understands 2 commands:
+
+ * `colorize` - Displays a ANSI colorized version of the source. This is mainly used for debugging the lexer.
+ * `rewrite` - Rewrites the source files in place to be correctly formatted
+
+Examples:
+
+    eden rewrite source_file.rb
+
+will rewrite source_file.rb
+
+    eden rewrite ./**/*.rb
+
+will rewrite all the .rb files in the current directory and any subdirectories.
+
+Eden was created by Jason Langenauer (jason@jasonlangenauer.com or @jasonlangenauer on Twitter). Any feedback/comments/suggestions gratefully received.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  test_files = FileList['test/**/*_test.rb']
+  t.test_files = test_files
+  t.verbose = true
+end

data/bin/eden

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+
+require 'optparse'
+require 'eden'
+
+# Automatically load all the formatters
+formatters = []
+
+# Taken from ActiveSupport
+def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+  if first_letter_in_uppercase
+    lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  else
+    lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+  end
+end
+
+# Load all the formatters
+Dir.glob([File.dirname(__FILE__) + "/../lib/eden/formatters/*.rb"] ) do |file|
+  require "#{file}"
+  const_name = camelize( File.basename(file, ".rb"))
+  formatters << Object.const_get( const_name )
+end
+
+# Setup defaults
+require 'eden/defaults'
+
+# Load formatting customizations
+if File.exists?("./config/eden.rb")
+   require './config/eden.rb'
+end
+
+# Displays a source file on STDOUT using ANSI escape codes for
+# syntax highlighting
+def colorize( sf )
+  sf.lines.each do |line|
+    print "[#{line.line_no}] "
+    line.tokens.flatten.each do |t|
+      case t.type
+      when :regex
+        print "\033[32m"
+        print t.content
+        print "\033[0m"
+      when :double_q_string, :single_q_string
+        print "\033[0;36m" + t.content + "\033[0m"
+      when :symbol
+        print "\033[31m" + t.content + "\033[0m"
+      when :instancevar
+        print "\033[1;34m" + t.content + "\033[0m"
+      when :comment
+        print "\033[1;30m" + t.content + "\033[0m"
+      else
+        if t.keyword?
+          print "\033[33m" + t.content + "\033[0m"
+        else
+          print t.content
+        end
+      end
+    end
+  end
+end
+
+def debug( source_file )
+  source_file.lines.each do |l|
+    puts l.tokens.inspect
+  end
+end
+
+
+# Load default options
+options = {}
+
+# Command-line options parser
+opts = OptionParser.new do |opts|
+  options[:recurse] = false
+  opts.banner = <<BANNER
+usage: eden command [options] source_files
+--
+Valid command options:
+colorize - display source file with syntax highlighting
+rewrite - rewrite the source file in place with adjusted formatting
+
+Options:
+BANNER
+  opts.on('-R', '--recursive', "Recursively search subdirectories") do 
+    options[:recurse] = true
+  end
+end
+
+source_files = []
+
+# Parse the command line, and find out what we want to do
+opts.parse!
+cmd = ARGV.shift
+
+unless cmd
+  puts opts
+  exit
+end
+
+cmd = cmd.downcase.to_sym
+
+unless [:colorize, :analyse, :rewrite, :debug].include?(cmd)
+  puts opts
+  exit
+end
+
+sf = nil
+
+begin
+  ARGV.each do |f|
+    sf = Eden::SourceFile.new( f )
+    sf.load!
+    sf.tokenize!
+    formatters.each do |formatter|
+      formatter.format( sf )
+    end
+    source_files << sf
+    case cmd
+    when :colorize then colorize( sf )
+    when :rewrite then sf.rewrite!
+    when :analyse then analyse( sf )
+    when :debug then debug( sf )
+    end
+  end
+rescue => e
+  puts e
+  sf.lines.each { |l| puts l.joined_tokens }
+end
+
+

data/lib/eden.rb

@@ -0,0 +1,10 @@
+require 'eden/token'
+require 'eden/tokenizer'
+require 'eden/source_file'
+require 'eden/line'
+
+require 'eden/formatter'
+
+
+
+

data/lib/eden/defaults.rb

@@ -0,0 +1,26 @@
+WhiteSpaceCleaner.configure do |w|
+  # Remove any white space after the last non-whitespace token?
+  w.remove_trailing_whitespace true
+end
+
+Indenter.configure do |i|
+  # Make any change to code indents at all?
+  i.adjust_indents true
+
+  # What character should be used to pad the indents
+  i.indent_character ' '
+
+  # How many of the indent_character should be used at each level of indent
+  i.indent_characters_per_step 2
+end
+
+BlockFormatter.configure do |b|
+  # Modify block spacing at all?
+  b.adjust_blocks true
+
+  # What charater to pad blocks with?
+  b.padding_character " "
+
+  # How many padding characters to use at each end of the inline block?
+  b.padding_character_count 1
+end

data/lib/eden/formatter.rb

@@ -0,0 +1,25 @@
+module Eden
+  # Formatter
+  # 
+  # A base class providing configuration behaviour for Eden's source code
+  # formatters.
+  class Formatter
+    class << self
+      attr_accessor :options
+    end
+
+    def self.configure
+      yield self
+    end
+
+    def self.format( source_file )
+      raise "Format function not implmented."
+    end
+
+    def self.method_missing(name, *args, &block)
+      self.options ||= {}
+      self.options[name.to_sym] = *args[0]
+    end
+  end
+end
+

data/lib/eden/formatters/block_formatter.rb

@@ -0,0 +1,45 @@
+# BlockFormatter
+#
+# Formats inline blocks ( including string interpolations ) by formatting the correct spacing
+# around the content of the block.
+#
+# Options:
+#
+# - adjust_blocks - (true|false) Make any changes at all to blocks?
+# - padding_character - (string) character to use to space between the content of the block and its braces
+# - padding_character_count - (integer) number of spaces to use after/before each brace. Can be 0.
+
+class BlockFormatter < Eden::Formatter
+  def self.format( source_file )
+    return unless options[:adjust_blocks]
+
+    space = (options[:padding_character] * options[:padding_character_count])
+    use_space = space.length != 0
+    
+    source_file.each_line do |line|
+      line.tokens.each do |token|
+        if token.is?( :lcurly )
+          next_token = line.next_token( token )
+          if next_token && next_token.content != space
+            if next_token.is?(:whitespace)
+              next_token.content == space
+            else
+              new_space_token = Eden::Token.new(:whitespace, space)
+              line.insert_token_after(token, new_space_token)
+            end
+          end
+        elsif token.is?( :rcurly )
+          prev_token = line.previous_token( token )
+          if prev_token && prev_token.content != space
+            if prev_token.is?( :whitespace )
+              prev_token.content == space
+            else
+              new_space_token = Eden::Token.new(:whitespace, space)
+              line.insert_token_before(token, new_space_token)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eden/formatters/indenter.rb

@@ -0,0 +1,91 @@
+class Indenter < Eden::Formatter
+  def self.format( source_file )
+    return unless options[:adjust_indents]
+    @current_indent = 0
+    source_file.each_line do |line|
+      next if line.tokens[0] && line.tokens[0].is?(:heredoc_body)
+      calculate_pre_indent(line)
+      adjust_indent(line)
+      calculate_post_indent(line)
+    end
+  end
+
+  private
+  # Calculates changes in indent relative to the previous line due to tokens in the current line
+  def self.calculate_pre_indent( line )
+    line.tokens.each do |t|
+      if [:end, :rescue, :else, :elsif].include?(t.type)
+        @current_indent -= 1 
+        line.tokens.each do |tok|
+          increase_indent! if [:class, :def, :module].include?(tok.type)
+        end
+      end
+
+      if t.is?( :when )
+        decrease_indent!
+      end
+    end
+    @current_indent = 0 if @current_indent < 0
+  end
+
+  def self.calculate_post_indent( line )
+    line.tokens.each do |t|
+      if [:class, :def, :module, :do, :begin, :rescue, :if, :else, :elsif, :case, :unless].include?(t.type)
+        increase_indent!
+        
+        # Handle suffix conditionals
+        if [:if, :unless].include?(t.type)
+          prev_token = line.previous_non_whitespace_token(t)
+          decrease_indent! if !prev_token.nil? || (prev_token && prev_token.type == :equals)
+        end
+
+        line.tokens.each do |tok|
+          decrease_indent! if tok.is?( :end )
+        end
+      end
+
+      if [:for, :until, :while].include?(t.type)
+        increase_indent!
+
+        if [:until, :while].include?(t.type)
+          prev_token = line.previous_non_whitespace_token(t)
+          decrease_indent! if !prev_token.nil? || (prev_token && prev_token.type == :equals)
+        end
+
+        line.tokens.each do |tok|
+          decrease_indent! if tok.is?( :do )
+        end
+      end
+
+      if t.is?(:when)
+        increase_indent!
+      end
+    end
+  end
+
+  def self.adjust_indent( line )
+    return unless line.tokens[0]
+    if @current_indent == 0
+      line.tokens.delete_at(0) if line.tokens[0].type == :whitespace
+    else
+      if line.tokens[0].is?( :whitespace )
+        line.tokens[0].content = indent_content
+      else
+        indent_token = Eden::Token.new( :whitespace, indent_content )
+        line.tokens.unshift(indent_token)
+      end
+    end
+  end
+
+  def self.indent_content
+    options[:indent_character] * (options[:indent_characters_per_step] * @current_indent)
+  end
+
+  def self.increase_indent!
+    @current_indent += 1
+  end
+
+  def self.decrease_indent!
+    @current_indent -=1 if @current_indent > 0
+  end
+end

data/lib/eden/formatters/white_space_cleaner.rb

@@ -0,0 +1,14 @@
+class WhiteSpaceCleaner < Eden::Formatter
+  def self.format( source_file )
+    return unless options[:remove_trailing_whitespace]
+
+    source_file.each_line do |l|
+      i = l.tokens.size - 1
+      while( i >= 0 )
+        break unless l.tokens[i].is?( :whitespace ) || l.tokens[i].is?( :newline )
+        l.tokens.delete_at(i) if l.tokens[i].is?( :whitespace )
+        i -= 1
+      end
+    end
+  end
+end

data/lib/eden/line.rb

@@ -0,0 +1,65 @@
+module Eden
+  class Line
+    attr_accessor :line_no, :tokens
+
+    def initialize( line_no )
+      @line_no = line_no
+      @tokens = []
+      @warnings = []
+    end
+
+    def flatten!
+      @tokens.flatten!
+      self
+    end
+
+    def last_token_is_space?
+      @tokens[-1].type == :whitespace
+    end
+
+    def joined_tokens
+      tokens.map { |t| t.content }.join('')
+    end
+
+    def previous_token( token )
+      token_index = tokens.index( token )
+      return nil if token_index.nil? || token_index == 0
+      return tokens[token_index-1]
+    end
+
+    def previous_non_whitespace_token( token )
+      token_index = tokens.index( token )
+      return nil if token_index.nil? || token_index == 0
+      token_index -= 1
+      while( token_index != 0 )
+        return tokens[token_index] if tokens[token_index].type != :whitespace
+        token_index -= 1
+      end
+      return nil
+    end
+
+    def next_token( token )
+      token_index = tokens.index( token )
+      return nil if token_index.nil? || token_index == tokens.length
+      return tokens[token_index+1]
+    end
+
+    def insert_token_after( token, new_token )
+      token_index = tokens.index( token )
+      if token_index.nil?
+        tokens.push( new_token )
+      else
+        tokens.insert( token_index+1, new_token )
+      end
+    end
+    
+    def insert_token_before( token, new_token )
+      token_index = tokens.index( token )
+      if token_index.nil?
+        tokens.unshift( new_token )
+      else
+        tokens.insert( token_index, new_token )
+      end
+    end
+  end
+end