ruby_scribe 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Ben Hughes
+
+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.rdoc

@@ -0,0 +1,104 @@
+= Ruby Scribe
+
+== Introduction
+
+Seattle RB's ruby_parser is a great tool for parsing ruby code into syntax trees.  Ruby Scribe is the reverse of this - a tool for taking an S-expression in Ruby and emitting clean code.  It does this by providing a series of rules that intelligently formats code much as a real developer would.
+
+== Example
+
+Imagine this crappily-formatted Ruby code:
+  
+  module RubyScribe
+
+
+    # My Comment
+    class Sample  < Base; 
+         def method; do_something_here; end
+
+     if(new_record?) then
+         puts "Yes"
+      else
+             puts 'No'
+        end
+    end
+   end
+
+Here is the syntax tree for the above:
+  
+  s(:module,
+   :RubyScribe,
+   s(:scope,
+    s(:class,
+     :Sample,
+     s(:const, :Base),
+     s(:scope,
+      s(:block,
+       s(:defn,
+        :method,
+        s(:args),
+        s(:scope, s(:block, s(:call, nil, :do_something_here, s(:arglist))))),
+       s(:if,
+        s(:call, nil, :new_record?, s(:arglist)),
+        s(:call, nil, :puts, s(:arglist, s(:str, "Yes"))),
+        s(:call, nil, :puts, s(:arglist, s(:str, "No")))))))))
+
+Parse that with RubyParser, then emit it with RubyScribe:
+  
+  sexp = RubyParser.new.parse(File.read("bad_code.rb"))
+  RubyScribe::Emitter.new.emit(sexp)
+
+And out pops this:
+  
+  module RubyScribe
+    # My Comment
+    class Sample < Base
+      def method
+        do_something_here
+      end
+
+      if new_record?
+        puts "Yes"
+      else
+        puts "No"
+      end
+    end
+  end
+
+
+== Applications
+
+The combination of these two tools allows some other interesting tools to be written.  One of example tool (and indeed the entire reason I started this project) is my rspecify tool, which can take a test directory with code written using Test::Unit and, via a Ruby Scribe Preprocessor, convert it into RSpec, automating 99% of what a human developer would normally have to do.
+
+Future projects using these two gems could be:
+* Automated refactoring tools
+* Tools that take a project and try to apply a set of "coding standards"
+* Tools that produce metrics on how much your code differs from the project's "coding standards" implementation.
+
+== Usage
+
+The entire project simply takes an incoming Sexp object (from the ruby_parser project) and emits a single string.  To do this just use an Emitter:
+  
+  RubyScribe::Emitter.new.emit(sexp)  # => "module Something..."
+
+== Emitter Implementation
+
+The +Emitter+ class is nothing but a bunch of recursion.  The main emit method is a big case block to offload handling of individual types to separate methods which handle and compose a big string, all through recursion.  
+
+To extend or implement your own Emitter, just subclass +RubyScribe::Emitter+ and override the necessary methods.
+
+== Preprocess Implementation
+
+This feature is not developed yet, but is intended on presenting a standard recursion-based class for implementing transformations of S-expressions.
+
+== Known Issues
+
+* Anything involving order of operations currently much surround the expression in ( ).  Will probably expand later to omit this when order of operations is implied, but this requires a context stack.
+* Elsif currently does not work as you'd expect and instead embeds another if block inside of the outer one's "else".  This is how if statements are presented via ruby_parser.  
+* Some of the more obscure types are not implemented.
+* Only comments on methods, class, and module declarations are retained.  This is actually a limitation of ruby_parser as for whatever reason 
+in-line comments cannot be parsed correctly.
+
+== Future Features
+
+* Maintain a context stack so emit methods can emit different content dependent on context in the stack
+* Configuration options for things such as block style, preference for quote style, etc.

data/Rakefile

@@ -0,0 +1,14 @@
+require "rubygems"
+require "rake"
+require "rake/rdoctask"
+
+desc "Generate documentation for the plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title    = "has_draft"
+  rdoc.options << "--line-numbers" << "--inline-source"
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Dir["#{File.dirname(__FILE__)}/lib/tasks/*.rake"].sort.each { |ext| load ext }

data/TODO.rdoc

@@ -0,0 +1,2 @@
+= TODO
+

data/lib/ruby_scribe.rb

@@ -0,0 +1,8 @@
+require "rubygems"
+require "active_support"
+require "ruby_parser"
+
+require "ruby_scribe/emitter_helpers"
+require "ruby_scribe/emitter"
+require "ruby_scribe/preprocessor"
+require "ruby_scribe/ext/sexp"

data/lib/ruby_scribe/emitter.rb

@@ -0,0 +1,446 @@
+require "active_support/core_ext"
+
+module RubyScribe
+  # Takes a proprocessed S-expression and emits formatted Ruby code
+  class Emitter
+    include EmitterHelpers
+    
+    cattr_accessor :methods_without_parenthesis
+    self.methods_without_parenthesis = %w(require gem puts attr_accessor cattr_accessor delegate alias_method alias)
+    
+    SYNTACTIC_METHODS = ['+', '-', '<<', '==', '===', '>', '<']
+    
+    def emit(e)
+      return "" unless e
+      return e if e.is_a?(String)
+      return e.to_s if e.is_a?(Symbol)
+      
+      case e.kind
+      when :block
+        emit_block(e)
+      when :scope
+        emit_scope(e)
+      when :rescue
+        emit_rescue(e)
+      when :module
+        emit_module_definition(e)
+      when :class
+        emit_class_definition(e)
+      when :sclass
+        emit_self_class_definition(e)
+      when :defn
+        emit_method_definition(e)
+      when :defs
+        emit_method_with_receiver_definition(e)
+      when :args
+        emit_method_argument_list(e)
+      when :call
+        emit_method_call(e)
+      when :arglist
+        emit_argument_list(e)
+      when :attrasgn
+        emit_attribute_assignment(e)
+      when :masgn
+        emit_multiple_assignment(e)
+      when :cdecl
+        emit_constant_declaration(e)
+      when :if, :unless
+        emit_conditional_block(e)
+      when :case
+        emit_case_statement(e)
+      when :when
+        emit_case_when_statement(e)
+      when :while, :until
+        emit_loop_block(e)
+      when :for
+        emit_for_block(e)
+      when :lasgn, :iasgn
+        emit_assignment_expression(e)
+      when :op_asgn_or
+        emit_optional_assignment_or_expression(e)
+      when :op_asgn_and
+        emit_optional_assignment_and_expression(e)
+      when :or, :and
+        emit_binary_expression(e)
+      when :iter
+        emit_block_invocation(e)
+      when :defined
+        emit_defined_invocation(e)
+      else
+        emit_token(e)
+      end || ""
+    end
+    
+    
+    protected
+    
+    def emit_comments(comments)
+      comments.present? ? (comments.split("\n").join(nl) + nl) : ""
+    end
+    
+    def emit_block(e)
+      return "" if e.body[0] == s(:nil)
+      
+      # Special case for handling rescue blocks around entire methods (excluding the indent):
+      return emit_method_rescue(e.body[0]) if e.body.size == 1 and e.body[0].kind == :rescue
+      
+      e.body.map do |child|
+        emit_block_member_prefix(e.body, child) + 
+        emit(child)
+      end.join(nl)
+    end
+    
+    def emit_block_member_prefix(members, current_member)
+      previous_member_index = members.index(current_member) - 1
+      previous_member = previous_member_index >= 0 ? members[previous_member_index] : nil
+      return "" unless previous_member
+      
+      [
+        [[:defn, :defs, :iter, :class, :module, :rescue], [:defn, :defs, :iter, :class, :module, :call, :rescue]],
+        [[:call], [:defn, :defs, :iter, :class, :module]]
+      ].each do |from, to|
+        return nl if (from == :any || from.include?(previous_member.kind)) && (to == :any || to.include?(current_member.kind))
+      end
+      
+      if current_member.kind == :if && [:block_if, :block_unless].include?(determine_if_type(current_member))
+        return nl
+      elsif previous_member.kind == :if && [:block_if, :block_unless].include?(determine_if_type(previous_member))
+        return nl
+      end
+      
+      ""
+    end
+    
+    def emit_scope(e)
+      emit(e.body[0])
+    end
+    
+    def emit_rescue(e)
+      "begin" + indent { nl + emit(e.body[0]) } +
+      nl("rescue ") + indent { nl + emit(e.body[1].body[1]) } + 
+      nl("end")
+    end
+    
+    def emit_method_rescue(e)
+      emit(e.body[0]) + 
+      indent(-2) { nl("rescue ") } + 
+      nl + emit(e.body[1].body[1])
+    end
+    
+    def emit_class_definition(e)
+      emit_comments(e.comments) + 
+      "#{e.kind} #{e.body[0]}" + 
+      (e.body[1] ? " < #{emit(e.body[1])}" : "") +
+      indent { nl + emit(e.body[2]) } + 
+      nl("end")
+    end
+    
+    def emit_self_class_definition(e)
+      "class << #{e.body[0]}" + 
+      indent { nl + emit(e.body[1]) } + 
+      nl("end")
+    end
+    
+    def emit_module_definition(e)
+      emit_comments(e.comments) +
+      "#{e.kind} #{e.body[0]}" + 
+      indent { nl + emit(e.body[1]) } + 
+      nl("end")
+    end
+    
+    def emit_method_definition(e)
+      emit_comments(e.comments) + 
+      "def #{e.body[0]}" + 
+      (e.body[1].body.empty? ? "" : "(#{emit(e.body[1])})") +
+      indent { nl + emit(e.body[2]) } + 
+      nl("end")
+    end
+    
+    def emit_method_with_receiver_definition(e)
+      emit_comments(e.comments) +
+      "def #{emit(e.body[0])}.#{e.body[1]}" + 
+      (e.body[2].body.empty? ? "" : "(#{emit(e.body[2])})") +
+      indent { nl + emit(e.body[3]) } + 
+      nl("end")
+    end
+    
+    def emit_method_argument_list(e)
+      [].tap do |array|
+        e.body.each do |child|
+          if child.is_a?(Sexp) and child.kind == :block
+            child.body.each do |body_child|
+              array[array.index(body_child.body[0])] = emit(body_child)
+            end
+          else
+            array << child
+          end
+        end
+      end.join(", ")
+    end
+    
+    def emit_method_call(e)
+      return emit_method_call_hash_access(e) if e.body[1] == :[]
+      return emit_method_call_hash_assignment(e) if e.body[1] == :[]=
+      
+      emit_method_call_receiver(e) + 
+      emit_method_call_name(e) + 
+      emit_method_call_arguments(e)
+    end
+    
+    def emit_method_call_receiver(e)
+      if e.body[0] && SYNTACTIC_METHODS.include?(e.body[1].to_s)
+        "#{emit(e.body[0])} "
+      elsif e.body[0]
+        "#{emit(e.body[0])}."
+      else
+        ""
+      end
+    end
+    
+    def emit_method_call_name(e)
+      emit(e.body[1])
+    end
+    
+    def emit_method_call_arguments(e)
+      if e.body[2].body.empty?
+        ""
+      elsif self.class.methods_without_parenthesis.include?(e.body[1].to_s)
+        " " + emit(e.body[2])
+      elsif SYNTACTIC_METHODS.include?(e.body[1].to_s)
+        " " + emit(e.body[2])
+      else
+        "(" + emit(e.body[2]) + ")"
+      end
+    end
+    
+    def emit_method_call_hash_access(e)
+      emit(e.body[0]) + "[" + emit(e.body[2]) + "]"
+    end
+    
+    def emit_method_call_hash_assignment(e)
+      emit(e.body[0]) + "[" + emit(e.body[2].body[0]) + "] = " + emit(e.body[2].body[1])
+    end
+    
+    
+    def emit_argument_list(e)
+      e.body.map do |child|
+        if child == e.body[-1] && child.kind == :hash
+          emit_hash_body(child)
+        else
+          emit(child)
+        end
+      end.join(", ")
+    end
+    
+    def emit_attribute_assignment(e)
+      return emit_method_call(e) if ['[]='].include?(e.body[1].to_s)
+      
+      emit(e.body[0]) + "." + e.body[1].to_s.gsub(/=$/, "") + " = " + emit(e.body[2])
+    end
+    
+    def emit_multiple_assignment(e)
+      left = e.body[0].body
+      right = e.body[1].body
+      
+      left.map {|c| c.body[0] }.join(", ") + " = " + right.map {|c| emit(c) }.join(", ")
+    end
+    
+    def emit_constant_declaration(e)
+      emit(e.body[0]) + " = " + emit(e.body[1])
+    end
+    
+    def determine_if_type(e)
+      if e.body[1] && e.body[2] && e.body[0].line == e.body[1].try(:line) && e.line == e.body[2].try(:line)
+        :terinary
+      elsif e.body[1] && !e.body[2] && e.line == e.body[1].line && e.body[1].kind != :block
+        :dangling_if
+      elsif !e.body[1] && e.body[2] && e.line == e.body[2].line && e.body[2].kind != :block
+        :dangling_unless
+      elsif e.body[1]
+        :block_if
+      elsif e.body[2]
+        :block_unless
+      end
+    end
+    
+    def emit_conditional_block(e)
+      case determine_if_type(e)
+      when :terinary
+        "#{emit(e.body[0])} ? #{emit(e.body[1] || s(:nil))} : #{emit(e.body[2] || s(:nil))}"
+      when :dangling_if
+        "#{emit(e.body[1])} if #{emit(e.body[0])}"
+      when :dangling_unless
+        "#{emit(e.body[2])} unless #{emit(e.body[0])}"
+      when :block_if
+        "if #{emit(e.body[0])}" + indent { nl + emit(e.body[1]) } + 
+        (e.body[2] ? (nl("else") + indent { nl + emit(e.body[2]) }) : "") + 
+        nl("end")
+      when :block_unless
+        "unless #{emit(e.body[0])}" + indent { nl + emit(e.body[2]) } +
+        nl("end")
+      end
+    end
+    
+    def emit_case_statement(e)
+      "case #{emit(e.body.first)}" + e.body[1..-2].map {|c| emit(c) }.join + emit_case_else_statement(e.body[-1]) + nl("end")
+    end
+    
+    def emit_case_when_statement(e)
+      nl("when #{emit_case_when_argument(e.body.first)}") + indent { nl + emit(e.body[1]) }
+    end
+    
+    def emit_case_else_statement(e)
+      if e
+        nl("else") + indent { nl + emit(e) }
+      else
+        ""
+      end
+    end
+    
+    def emit_case_when_argument(e)
+      emit(e).gsub(/^\[/, '').gsub(/\]$/, '')
+    end
+    
+    def emit_loop_block(e)
+      "#{e.kind} #{e.body.first}" + 
+      indent { emit(e.body[1]) } + 
+      nl("end")
+    end
+    
+    def emit_for_block(e)
+      "for #{e.body[1].body[0]} in #{emit(e.body[0])}" + 
+      indent { nl + emit(e.body[2]) } + 
+      nl("end")
+    end
+    
+    def emit_assignment_expression(e)
+      "#{e.body[0]} = #{emit(e.body[1])}"
+    end
+    
+    def emit_optional_assignment_or_expression(e)
+      emit(e.body[0]) + " ||= " + emit(e.body[1].body[1])
+    end
+    
+    def emit_optional_assignment_and_expression(e)
+      emit(e.body[0]) + " &&= " + emit(e.body[1].body[1])
+    end
+    
+    def emit_binary_expression(e)
+      "(" + emit(e.body[0]) + " " + 
+      (e.kind == :and ? "&&" : "||") + 
+      " " + emit(e.body[1]) + ")"
+    end
+    
+    def emit_block_invocation(e)
+      emit(e.body[0]) + emit_block_invocation_body(e)
+    end
+    
+    def emit_block_invocation_body(e)
+      # If it's on the same line, it should probably be shorthand form:
+      if e.line == e.body[2].try(:line)
+        " {#{emit_block_invocation_arguments(e)} #{emit(e.body[2])} }"
+      else
+        " do #{emit_block_invocation_arguments(e)}".gsub(/ +$/, '') + 
+        indent { nl + emit(e.body[2]) } + 
+        nl("end")
+      end
+    end
+    
+    def emit_block_invocation_arguments(e)
+      if e.body[1]
+        "|" + emit_assignments_as_arguments(e.body[1]) + "| "
+      else
+        ""
+      end
+    end
+    
+    def emit_assignments_as_arguments(e)
+      if e.kind == :masgn
+        e.body[0].body.map {|c| emit_assignments_as_arguments(c) }.join(", ")
+      elsif e.kind == :lasgn
+        e.body[0].to_s
+      elsif e.kind == :splat
+        "*" + emit_assignments_as_arguments(e.body[0])
+      end
+    end
+    
+    def emit_defined_invocation(e)
+      "defined?(#{emit(e.body[0])})"
+    end
+    
+    def emit_token(e)
+      case e.kind
+      when :str
+        '"' + e.body[0] + '"'
+      when :lit
+        e.body[0].inspect
+      when :const
+        e.body[0].to_s
+      when :lvar
+        e.body[0].to_s
+      when :ivar
+        e.body[0].to_s
+      when :not
+        "!" + emit(e.body[0])
+      when :true
+        "true"
+      when :false
+        "false"
+      when :nil
+        "nil"
+      when :self
+        "self"
+      when :zsuper
+        "super"
+      when :super
+        "super(" + e.body.map {|c| emit(c) }.join(", ") + ")"
+      when :yield
+        "yield #{emit_argument_list(e)}".strip
+      when :next
+        "next"
+      when :retry
+        "retry"
+      when :return
+        "return #{emit_argument_list(e)}".strip
+      when :alias
+        "alias #{emit(e.body[0])} #{emit(e.body[1])}"
+      when :block_pass
+        "&" + emit(e.body[0])
+      when :splat
+        "*" + emit(e.body[0])
+      when :colon2
+        "#{emit(e.body[0])}::#{e.body[1].to_s}"
+      when :hash
+        "{" + emit_hash_body(e) + "}"
+      when :array
+        "[" + e.body.map {|c| emit(c)}.join(", ") + "]"
+      when :gvar
+        e.body[0].to_s
+      when :dstr
+        '"' + literalize_strings(e.body).map {|c| emit(c) }.join + '"'
+      when :evstr
+        '#{' + emit(e.body[0]) + '}'
+      when :xstr
+        '`' + emit(e.body[0]) + '`'
+      when :dxstr
+        '`' + literalize_strings(e.body).map {|c| emit(c) }.join + '`'
+      when :dsym
+        ':"' + literalize_strings(e.body).map {|c| emit(c) }.join + '"'
+      when :match3
+        emit(e.body[1]) + " =~ " + emit(e.body[0])
+      when :cvdecl
+        emit(e.body[0].to_s) + " = " + emit(e.body[1])
+      else
+        emit_unknown_expression(e)
+      end
+    end
+    
+    def emit_hash_body(e)
+      e.body.in_groups_of(2).map {|g| "#{emit(g[0])} => #{emit(g[1])}" }.join(", ")
+    end
+    
+    def emit_unknown_expression(e)
+      nl("## UNKNOWN: #{e.kind} ##")
+    end
+  end
+end

data/lib/ruby_scribe/emitter_helpers.rb

@@ -0,0 +1,28 @@
+module RubyScribe
+  module EmitterHelpers
+    def indents
+      @indents ||= []
+    end
+    
+    def indent_level
+      indents.inject(0) {|b,i| b + i } || 0
+    end
+    
+    def indent(level = 2)
+      indents.push(level)
+      output = yield
+      indents.pop
+      output
+    end
+    
+    def nl(text = "")
+      "\n" + (" " * indent_level) + text
+    end
+    
+    def literalize_strings(sexps)
+      sexps.map do |sexp|
+        sexp.is_a?(Sexp) && sexp.kind == :str ? sexp.body[0] : sexp
+      end
+    end
+  end
+end

data/lib/ruby_scribe/ext/sexp.rb

@@ -0,0 +1,9 @@
+class Sexp
+  def kind
+    sexp_type.to_sym
+  end
+  
+  def body
+    sexp_body
+  end
+end

data/lib/ruby_scribe/preprocessor.rb

@@ -0,0 +1,9 @@
+module RubyScribe
+  # Takes a raw S-expression and proprocesses it.  To use, simply subclass and override the preprocess method.
+  # Catch any instances you want to handle as it drills down the chain
+  class Preprocessor
+    def proprocess(sexp)
+      
+    end
+  end
+end

data/lib/ruby_scribe/runner.rb

@@ -0,0 +1,32 @@
+require "thor"
+
+module RubyScribe
+  class Runner < Thor
+    desc :cat, "Takes a single ruby file, parses it, and outputs the scribed version."
+    def cat(path)
+      sexp = RubyParser.new.parse(File.read(path))
+      puts RubyScribe::Emitter.new.emit(sexp)
+    end
+    
+    desc :convert, "Takes a single file or multiple files, parses them, then replaces the original file(s) with the scribed version."
+    def convert(*paths)
+      expand_paths(paths).each do |path|
+        sexp = RubyParser.new.parse(File.read(path))
+        output = RubyScribe::Emitter.new.emit(sexp)
+        
+        File.open(path, "w") do |file|
+          file.write(output)
+          file.flush
+        end
+      end
+    end
+    
+    protected
+    
+    def expand_paths(paths = [])
+      paths.map do |path|
+        [path] + Dir[path + "**/*.rb"]
+      end.flatten.uniq.reject {|f| File.directory?(f) }
+    end
+  end
+end

data/lib/ruby_scribe/version.rb

@@ -0,0 +1,3 @@
+module RubyScribe
+  VERSION = "0.0.1"
+end

data/lib/tasks/scribe.rake

@@ -0,0 +1,29 @@
+namespace :scribe do
+  desc "Run Scribe Examples"
+  task :examples do
+    $:.unshift(File.join(File.dirname(__FILE__), ".."))
+    require "ruby_parser"
+    require "ruby_scribe"
+    require "pp"
+    
+    original_file = File.read(File.join(File.dirname(__FILE__), "../../spec/examples/simple_class_with_methods.rb"))
+    sexp = RubyParser.new.parse(original_file)
+    
+    puts "Parsed S-Expresssion"
+    puts "======================================"
+    pp sexp
+    puts
+    
+    puts "Original File"
+    puts "======================================"
+    puts original_file
+    
+    puts
+    puts
+    
+    puts "Parsed File"
+    puts "======================================"
+    parsed_file = RubyScribe::Emitter.new.emit(sexp)
+    puts parsed_file
+  end
+end

data/spec/examples/simple_class_with_methods.rb

@@ -0,0 +1,14 @@
+module RubyScribe
+  
+  
+  # My Comment
+  class Sample  < Base; 
+       def method; do_something_here; end
+    
+   if(new_record?) then
+       puts "Yes"
+    else
+           puts 'No'
+      end
+  end
+ end

data/spec/proprocessor_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe RubyScribe::Preprocessor do
+  subject { RubyScribe::Proprocessor.new }
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.join(File.dirname(__FILE__), "../lib"))
+
+require "rubygems"
+require "rspec"
+require "ruby_scribe"
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/matchers/**/*.rb"].each {|f| require f}

data/spec/strategy_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe RubyScribe::Strategy do
+  before do
+    @strategy = RubyScribe::Strategy.new
+  end
+  
+  
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: ruby_scribe
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ben Hughes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-25 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby_parser
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 17
+        segments: 
+        - 0
+        - 13
+        version: "0.13"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id003
+description: A ruby formatting tool that takes S-expression as input and intelligently outputs formatted Ruby code.
+email: ben@railsgarden.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ruby_scribe/emitter.rb
+- lib/ruby_scribe/emitter_helpers.rb
+- lib/ruby_scribe/ext/sexp.rb
+- lib/ruby_scribe/preprocessor.rb
+- lib/ruby_scribe/runner.rb
+- lib/ruby_scribe/version.rb
+- lib/ruby_scribe.rb
+- lib/tasks/scribe.rake
+- spec/examples/simple_class_with_methods.rb
+- spec/proprocessor_spec.rb
+- spec/spec_helper.rb
+- spec/strategy_spec.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+- TODO.rdoc
+has_rdoc: true
+homepage: http://github.com/rubiety/ruby_scribe
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 19
+      segments: 
+      - 1
+      - 3
+      - 4
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: ruby_scribe
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Generates formatted ruby code from S-expressions (like from ruby_parser).
+test_files: []
+