synvert 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4aefc7425f57552493435e868b3bbaae081a97ba
-  data.tar.gz: d679d3dd07f996bf238f540a842c9f99a758d7d4
+  metadata.gz: cf669115cf6d65444d15559b42836533143c76e2
+  data.tar.gz: b89a1714b73c29a5f66b4a320a3fa5c76b6feeb8
 SHA512:
-  metadata.gz: b213405f6988e2041a4e087128319ed1cc5fead180dc58a269f6852c426f50b5bb5b322fc93839a2055d6d5f01809086ba6bd3d95052c47fcf64396af60bc6bc
-  data.tar.gz: 630fbc831d76015d8ca0ea2ff958a87efab5a7be7ff5afd1d9d3a3a766039ad5ad59d67c8be6b7f969f48e96dff58cc65e28499ba5eea3ba00845716026e1f5d
+  metadata.gz: 3d4dac67ebafd169d5f44e4022d2102fa4de6d6d35954830583ce8277851eb945c7039263eda058992979814c6e10945bcde74533c59f4872dedad304b61fbbf
+  data.tar.gz: cbd540c9732b62c3fb6fdd6897fdc538aa17dbde38b037acfae1240bd3b89617485ac32631d9e1a381cbaa48bb940d02044f0163185a096d86e715f548257d28

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# CHANGELOG
+
+## 0.0.2
+
+* Rewrite all stuff, dsl style rather than inherit Parser::Rewriter
+
+## 0.0.1
+
+* First version

data/README.md

@@ -1,6 +1,9 @@
 # Synvert
 
-TODO: Write a gem description
+synvert = syntax + convert, makes it easy to rewrite ruby code
+automatically.
+
+**synvert is still in alpha stage**
 
 ## Installation
 
@@ -18,7 +21,11 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+    synvert PROJECT_PATH
+
+Currently it supports
+
+* FactoryGirl short syntax
 
 ## Contributing
 

data/lib/synvert.rb

@@ -3,12 +3,11 @@ require "synvert/version"
 require 'parser'
 require 'parser/current'
 require 'ast'
+require 'synvert/node_ext'
 
 module Synvert
   autoload :BaseConverter, 'synvert/base_converter'
   autoload :CheckingVisitor, 'synvert/checking_visitor'
-  autoload :SexpHelper, 'synvert/sexp_helper'
-  module FactoryGirl
-    autoload :SyntaxMethodsConverter, 'synvert/factory_girl/syntax_methods_converter'
-  end
+  autoload :Configuration, 'synvert/configuration'
+  autoload :Rewriter, 'synvert/rewriter'
 end

data/lib/synvert/cli.rb

@@ -1,23 +1,24 @@
 # coding: utf-8
+require 'optparse'
 require 'find'
 
 module Synvert
   class CLI
-    def self.run
-      new.run
+    def self.run(args = ARGV)
+      new.run(args)
     end
 
-    def initialize
-      @checking_visitor = CheckingVisitor.new
-    end
+    def run(args)
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: synvert path"
+      end
+      paths = optparse.parse(args)
+      Configuration.instance.set :path, paths.first || Dir.pwd
+
+      load(File.join(File.dirname(__FILE__), 'factory_girl/syntax_methods.rb'))
 
-    def run
-      Find.find(".") do |path|
-        if FileTest.directory?(path)
-          next
-        else
-          @checking_visitor.convert_file(path) if path =~ /\.rb$/
-        end
+      ObjectSpace.each_object Synvert::Rewriter do |rewriter|
+        rewriter.process
       end
     end
   end

data/lib/synvert/configuration.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+require 'singleton'
+
+module Synvert
+  class Configuration < Hash
+    include Singleton
+
+    def set(key, value)
+      self[key] = value
+    end
+
+    def get(key)
+      self[key]
+    end
+  end
+end

data/lib/synvert/factory_girl/syntax_methods.rb

@@ -0,0 +1,37 @@
+Synvert::Rewriter.new "use short syntax" do
+  from_version '2.0.0'
+
+  within_file 'spec/spec_helper.rb' do
+    within_node type: 'block', caller: {receiver: 'RSpec', message: 'configure'} do
+      unless_exist_node type: 'send', message: 'include', arguments: {first: {to_s: 'FactoryGirl::Syntax::Methods'}} do
+        insert "{{node.arguments.first}}.include FactoryGirl::Syntax::Methods"
+      end
+    end
+  end
+
+  %w(Test::Unit::TestCase ActiveSupport::TestCase MiniTest::Unit::TestCase MiniTest::Spec MiniTest::Rails::ActiveSupport::TestCase).each do |class_name|
+    within_file 'test/test_helper.rb' do
+      within_node type: 'class', name: class_name do
+        unless_exist_node type: 'send', message: 'include', arguments: {first: {to_s: 'FactoryGirl::Syntax::Methods'}} do
+          insert "include FactoryGirl::Syntax::Methods"
+        end
+      end
+    end
+  end
+
+  within_file 'features/support/env.rb' do
+    unless_exist_node type: 'send', message: 'World', arguments: {first: {to_s: 'FactoryGirl::Syntax::Methods'}} do
+      insert "World(FactoryGirl::Syntax::Methods)"
+    end
+  end
+
+  %w(test/**/*.rb spec/**/*.rb features/**/*.rb).each do |file_pattern|
+    %w(create build attributes_for build_stubbed create_list build_list ccreate_pair build_pair).each do |message|
+      within_files file_pattern do
+        with_node type: 'send', receiver: 'FactoryGirl', message: message do
+          replace_with "#{message}({{node.arguments}})"
+        end
+      end
+    end
+  end
+end

data/lib/synvert/node_ext.rb

@@ -0,0 +1,134 @@
+class Parser::AST::Node
+  def name
+    if :class == self.type
+      self.children[0]
+    else
+      raise NotImplementedError.new "name is not handled for #{self.inspect}"
+    end
+  end
+
+  def receiver
+    if :send == self.type
+      self.children[0]
+    else
+      raise NotImplementedError.new "receiver is not handled for #{self.inspect}"
+    end
+  end
+
+  def message
+    if :send == self.type
+      self.children[1]
+    else
+      raise NotImplementedError.new "message is not handled for #{self.inspect}"
+    end
+  end
+
+  def arguments
+    case self.type
+    when :send
+      self.children[2..-1]
+    when :block
+      self.children[1].children
+    else
+      raise NotImplementedError.new "arguments is not handled for #{self.inspect}"
+    end
+  end
+
+  def caller
+    if :block == self.type
+      self.children[0]
+    else
+      raise NotImplementedError.new "caller is not handled for #{self.inspect}"
+    end
+  end
+
+  def to_s
+    case self.type
+    when :const
+      self.children.compact.map(&:to_s).join('::')
+    when :sym
+      ':' + self.children[0].to_s
+    when :str, :arg, :lvar, :ivar
+      self.children[0].to_s
+    else
+    end
+  end
+
+  def indent
+    self.loc.expression.column
+  end
+
+  def recursive_children
+    self.children.each do |child|
+      if Parser::AST::Node === child
+        yield child
+        child.recursive_children { |c| yield c }
+      end
+    end
+  end
+
+  def grep_node(options)
+    self.recursive_children do |child|
+      return child if child.match?(options)
+    end
+  end
+
+  def match?(options)
+    flat_hash(options).keys.all? do |key|
+      actual = actual_value(self, key)
+      expected = expected_value(options, key)
+      match_value?(actual, expected)
+    end
+  end
+
+  def to_source(code)
+    code.gsub(/{{(.*)}}/) do
+      node = self # node is used in eval
+      evaluated = eval($1)
+      if Parser::AST::Node === evaluated
+        source = evaluated.loc.expression.source_buffer.source
+        source[evaluated.loc.expression.begin_pos...evaluated.loc.expression.end_pos]
+      else # Array
+        source = evaluated.first.loc.expression.source_buffer.source
+        source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
+      end
+    end
+  end
+
+private
+
+  def match_value?(actual, expected)
+    case actual
+    when Symbol
+      actual == expected.to_sym
+    when Array
+      actual.zip(expected).all? { |a, e| match_value?(a, e) }
+    else
+      actual.to_s == expected
+    end
+  end
+
+  def flat_hash(h, k = [])
+    new_hash = {}
+    h.each_pair do |key, val|
+      if val.is_a?(Hash)
+        new_hash.merge!(flat_hash(val, k + [key]))
+      else
+        new_hash[k + [key]] = val
+      end
+    end
+    new_hash
+  end
+
+  def actual_value(node, multi_keys)
+    multi_keys.inject(node) { |n, key| n.send(key) }
+  end
+
+  def expected_value(options, multi_keys)
+    multi_keys.inject(options) { |o, key| o[key] }
+  end
+
+  #def to_ast(str)
+    #Parser::CurrentRuby.parse(str)
+  #end
+end

data/lib/synvert/rewriter.rb

@@ -0,0 +1,56 @@
+module Synvert
+  class Rewriter
+    autoload :Action, 'synvert/rewriter/action'
+    autoload :ReplaceWithAction, 'synvert/rewriter/action'
+    autoload :InsertAction, 'synvert/rewriter/action'
+
+    autoload :Instances, 'synvert/rewriter/instances'
+
+    autoload :Scopes, 'synvert/rewriter/scopes'
+    autoload :Scope, 'synvert/rewriter/scopes'
+
+    autoload :Conditions, 'synvert/rewriter/conditions'
+    autoload :Condition, 'synvert/rewriter/conditions'
+    autoload :UnlessExistCondition, 'synvert/rewriter/conditions'
+
+    attr_reader :description, :version, :instances
+
+    def initialize(description, &block)
+      @description = description
+      @instances = Instances.new
+      instance_eval &block if block_given?
+    end
+
+    def process
+      @instances.process
+    end
+
+    def from_version(version)
+      @version = Version.from_string(version)
+    end
+
+    def within_file(file, &block)
+      @instances.add(file, &block)
+    end
+
+    def within_files(files, &block)
+      @instances.add(files, &block)
+    end
+
+    class Version
+      def self.from_string(version)
+        self.new *version.split('.')
+      end
+
+      def initialize(major, minor, patch)
+        @major = major
+        @minor = minor
+        @patch = patch
+      end
+
+      def to_s
+        [@major, @minor, @patch].join('.')
+      end
+    end
+  end
+end

data/lib/synvert/rewriter/action.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module Synvert
+  class Rewriter::Action
+    def initialize(code)
+      @code = code
+    end
+
+    def rewrite(source, node)
+      raise NotImplementedError.new 'rewrite method is not implemented'
+    end
+  end
+
+  class Rewriter::ReplaceWithAction < Rewriter::Action
+    def rewrite(source, node)
+      begin_pos = node.loc.expression.begin_pos
+      end_pos = node.loc.expression.end_pos
+      source[begin_pos...end_pos] = node.to_source(@code)
+      source
+    end
+  end
+
+  class Rewriter::InsertAction < Rewriter::Action
+    def rewrite(source, node)
+      source[insert_position(node), 0] = "\n" + insert_indent(node) + node.to_source(@code)
+      source
+    end
+
+    def insert_position(node)
+      case node.type
+      when :block
+        node.children[1].loc.expression.end_pos
+      when :class
+        node.children[0].loc.expression.end_pos
+      else
+        node.children.last.loc.expression.end_pos
+      end
+    end
+
+    def insert_indent(node)
+      if [:block, :class].include? node.type
+        ' ' * (node.indent + 2)
+      else
+        ' ' * node.indent
+      end
+    end
+  end
+end

data/lib/synvert/rewriter/conditions.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Synvert
+  class Rewriter::Conditions
+    def initialize
+      @conditions = []
+    end
+
+    def add(condition)
+      @conditions << condition
+    end
+
+    def matching_nodes(nodes)
+      @conditions.each do |condition|
+        break if nodes.empty?
+        nodes = condition.matching_nodes(nodes)
+      end
+      nodes
+    end
+  end
+
+  class Rewriter::Condition
+    def initialize(options)
+      @options = options
+    end
+  end
+
+  class Rewriter::UnlessExistCondition < Rewriter::Condition
+    def matching_nodes(nodes)
+      nodes.find_all { |node|
+        match = false
+        node.recursive_children do |child_node|
+          match = match || (child_node && child_node.match?(@options))
+        end
+        !match
+      }
+    end
+  end
+end

data/lib/synvert/rewriter/instances.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Synvert
+  class Rewriter::Instances
+    def initialize
+      @instances = []
+    end
+
+    def add(file_pattern, &block)
+      instance = Rewriter::Instance.new(file_pattern)
+      instance.instance_eval &block if block_given?
+      @instances << instance
+    end
+
+    def process
+      @instances.each { |instance| instance.process }
+    end
+  end
+
+  class Rewriter::Instance
+    def initialize(file_pattern)
+      @file_pattern = file_pattern
+      @scopes = Rewriter::Scopes.new
+      @conditions = Rewriter::Conditions.new
+    end
+
+    def process
+      parser = Parser::CurrentRuby.new
+      file_pattern = File.join(Configuration.instance.get(:path), @file_pattern)
+      Dir.glob(file_pattern).each do |path|
+        source = File.read(path)
+        buffer = Parser::Source::Buffer.new path
+        buffer.source = source
+
+        parser.reset
+        ast = parser.parse buffer
+
+        scoped_nodes = @scopes.matching_nodes(ast)
+        matching_nodes = @conditions.matching_nodes(scoped_nodes)
+        matching_nodes.reverse.each do |node|
+          source = @action.rewrite(source, node)
+        end
+        File.write path, source
+      end
+    end
+
+    def within_node(options, &block)
+      @scopes.add(options)
+      instance_eval &block if block_given?
+    end
+
+    alias with_node within_node
+
+    def unless_exist_node(options, &block)
+      @conditions.add(Rewriter::UnlessExistCondition.new(options))
+      instance_eval &block if block_given?
+    end
+
+    def insert(code)
+      @action = Rewriter::InsertAction.new(code)
+    end
+
+    def replace_with(code)
+      @action = Rewriter::ReplaceWithAction.new(code)
+    end
+  end
+end