arel_converter 0.0.1

data/lib/arel_converter/replacement.rb

@@ -0,0 +1,21 @@
+module ArelConverter
+  class Replacement
+    include Comparable
+
+    attr_accessor :old_content, :new_content, :error
+
+    def initialize(old_content=nil, new_content=nil)
+      @old_content = old_content
+      @new_content = new_content
+    end
+
+    def valid?
+      @error.nil?
+    end
+
+    def <=>(other)
+      [self.old_content, self.new_content] <=> [other.old_content, other.new_content]
+    end
+
+  end
+end

data/lib/arel_converter/scope.rb

@@ -0,0 +1,22 @@
+module ArelConverter
+  class Scope < Base
+
+    def grep_matches_in_file(file)
+      raw_named_scopes = `grep -h -r "^\s*scope\s*:" #{file}`
+      raw_named_scopes.split("\n")
+    end
+
+    def process_line(line)
+      new_scope = ArelConverter::Translator::Scope.translate(line)
+      new_scope.gsub(/scope\((.*)\)$/, 'scope \1')
+    end
+
+    def verify_line(line)
+      parser = RubyParser.new
+      sexp   = parser.process(line)
+      sexp[0] == :call && sexp[2] == :scope
+    end
+
+  end
+
+end

data/lib/arel_converter/translators/association.rb

@@ -0,0 +1,71 @@
+module ArelConverter
+  module Translator
+    class Association < Base
+
+      def process_call(exp)
+        @association_type ||= exp[1]
+        super
+      end
+
+      def process_hash(exp) # :nodoc:
+        @options = []
+        scopes = [:hash]
+        
+        until exp.empty?
+          lhs = exp.shift
+          rhs = exp.shift
+          if option_nodes.include?(lhs)
+            lhs = process(lhs)
+            t   = rhs.first
+            rhs = process rhs
+            rhs = "(#{rhs})" unless [:lit, :str, :true, :false].include? t # TODO: verify better!
+
+            @options << format_for_hash(lhs,rhs)
+          else
+            scopes += [lhs, rhs]
+          end
+        end
+        @options = nil if @options.empty?
+        @scopes  = Options.translate(Sexp.from_array(scopes)) unless scopes == [:hash]
+        return ''
+      end
+
+      def post_processing(new_scope)
+        new_scope.gsub!(/has_(many|one|and_belongs_to_many)\((.*)\)$/, 'has_\1 \2')
+        new_scope.gsub!(/belongs_to\((.*)\)$/, 'belongs_to \1')
+        [new_scope, format_scope(@scopes), @options].compact.join(', ')
+      end
+
+    protected
+
+      def format_scope(scopes)
+        return nil if scopes.nil? || scopes.empty?
+        "-> { #{scopes.strip} }" unless scopes.nil? || scopes.empty?
+      end
+
+      def option_nodes
+        [
+          s(:lit, :counter_cache),
+          s(:lit, :polymorphic),
+          s(:lit, :touch),
+          s(:lit, :as),
+          s(:lit, :autosave),
+          s(:lit, :class_name),
+          s(:lit, :dependent),
+          s(:lit, :foreign_key),
+          s(:lit, :inverse_of),
+          s(:lit, :primary_key),
+          s(:lit, :source),
+          s(:lit, :source_type),
+          s(:lit, :through),
+          s(:lit, :validate),
+          s(:lit, :association_foreign_key),
+          s(:lit, :autosave),
+          s(:lit, :join_table)
+        ]
+      end
+
+    end
+  end
+end
+

data/lib/arel_converter/translators/base.rb

@@ -0,0 +1,49 @@
+module ArelConverter
+  module Translator
+    class Base < Ruby2Ruby
+
+      LINE_LENGTH = 1_000
+
+      def self.translate(klass_or_str, method = nil)
+        sexp = klass_or_str.is_a?(String) ? self.parse(klass_or_str) : klass_or_str
+        processor = self.new
+        source = processor.process(sexp)
+        processor.post_processing(source)
+      end
+
+      def self.parse(code)
+        RubyParser.new.process(code)
+      end
+
+      def logger
+        @logger ||= setup_logger
+      end
+
+      def post_processing(source)
+        source
+      end
+
+      def format_for_hash(key, value)
+        key =~ /\A:/ ? "#{key.sub(':','')}: #{value}" : "#{key} => #{value}"
+      end
+
+    private
+
+      def setup_logger(log_level = :info)
+        logging = Logging::Logger[self]
+        layout = Logging::Layouts::Pattern.new(:pattern => "[%d, %c, %5l] %m\n")
+
+        stdout = Logging::Appenders.stdout
+        stdout.level = log_level
+
+        #file = Logging::Appenders::File.new("./log/converters.log")
+        #file.layout = layout
+        #file.level = :debug
+
+        logging.add_appenders(stdout)
+        logging
+      end
+
+    end
+  end
+end

data/lib/arel_converter/translators/finder.rb

@@ -0,0 +1,28 @@
+module ArelConverter
+  module Translator
+    class Finder < Base
+
+      def process_call(exp)
+        case exp[1]
+        when :all, :first
+          parent = process(exp.shift)
+          method = (exp.shift == :first ? 'first' : 'all')
+          unless exp.empty?
+            options = Options.translate(exp.shift).strip
+            method = nil if method == 'all'
+          end
+          [parent, options, method].compact.join('.')
+        when :find
+          parent = process(exp.shift)
+          exp.shift # Replacing so we can discard the :find definition
+          first_or_all = process(exp.shift) == ':first' ? 'first' : nil
+          options = Options.translate(exp.shift).strip unless exp.empty?
+          [parent, options, first_or_all].compact.join('.')
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/arel_converter/translators/options.rb

@@ -0,0 +1,172 @@
+module ArelConverter
+  module Translator
+    class Options < Base
+
+      LINE_LENGTH = 1_000
+
+      def logger
+        @logger ||= setup_logger
+      end
+
+      def process_hash(exp) # :nodoc:
+        @depth ||= 0
+        @depth += 1
+
+        result = []
+
+        until exp.empty?
+          lhs = process(exp.shift)
+          rhs = process(exp.shift)
+          result << (@depth > 1 ? format_for_hash(lhs,rhs) : hash_to_arel(lhs,rhs))
+        end
+
+        @depth -= 1
+
+        case @depth
+        when 0
+          result.empty? ? "" : result.join('.')
+        else
+          result.empty? ? "{}" : "{ #{result.join(', ')} }"
+        end
+      end
+
+      def process_call(exp)
+        if valid_arel_method?(exp[1])
+          @depth ||= 0
+          @depth += 1 if @depth == 0
+        end
+        super
+      end
+
+      def hash_to_arel(lhs, rhs)
+        key = lhs.sub(':','')
+        case key
+        when 'conditions'
+          key = 'where'
+        when 'include'
+          key = 'includes'
+        when 'none', 'reverse_order'
+          return key
+        end
+        rhs = rhs.gsub(/\A\[(.*)\]\z/, '\1').gsub(/\A\{(.*)\}\z/, '\1')
+        "#{key}(#{rhs})"
+      end
+
+      # Have to override super class to get the overridden LINE_LENGTH
+      # constant to work
+      def process_iter(exp) # :nodoc:
+        iter = process exp.shift
+        args = exp.shift
+        body = exp.empty? ? nil : process(exp.shift)
+
+        args = case args
+               when 0 then
+                 iter = '->' # no args? let's use a stubby
+                 ''
+               else
+                 a = process(args)[1..-2]
+                 a = " |#{a}|" unless a.empty?
+                 a
+               end
+        
+        b, e = if iter == "END" then
+                 [ "{", "}" ]
+               else
+                 [ "do", "end" ]
+               end
+
+        iter.sub!(/\(\)$/, '')
+
+        # REFACTOR: ugh
+        result = []
+        result << "#{iter} {"
+        result << args
+        if body then
+          result << " #{body.strip} "
+        else
+          result << ' '
+        end
+        result << "}"
+        result = result.join
+        return result if result !~ /\n/ and result.size < LINE_LENGTH
+
+        result = []
+        result << "#{iter} #{b}"
+        result << args
+        result << "\n"
+        if body then
+          result << indent(body.strip)
+          result << "\n"
+        end
+        result << e
+        result.join
+      end
+
+      def process_if(exp) # :nodoc:
+        expand = Ruby2Ruby::ASSIGN_NODES.include? exp.first.first
+        c = process exp.shift
+        t = process exp.shift
+        f = process exp.shift
+
+        c = "(#{c.chomp})" if c =~ /\n/
+
+        if t then
+          unless expand then
+            if f then
+              r = "#{c} ? (#{t}) : (#{f})"
+              r = nil if r =~ /return/ # HACK - need contextual awareness or something
+            else
+              r = "#{t} if #{c}"
+            end
+            return r if r and (@indent+r).size < LINE_LENGTH and r !~ /\n/
+          end
+
+          r = "if #{c} then\n#{indent(t)}\n"
+          r << "else\n#{indent(f)}\n" if f
+          r << "end"
+
+          r
+        elsif f
+          unless expand then
+            r = "#{f} unless #{c}"
+            return r if (@indent+r).size < LINE_LENGTH and r !~ /\n/
+          end
+          "unless #{c} then\n#{indent(f)}\nend"
+        else
+          # empty if statement, just do it in case of side effects from condition
+          "if #{c} then\n#{indent '# do nothing'}\nend"
+        end
+      end
+
+      private
+
+      def valid_arel_method?(m)
+        %w[bind
+          create_with
+          eager_load
+          extending
+          from
+          group
+          having
+          includes
+          joins
+          limit
+          lock
+          none
+          offset
+          order
+          preload
+          readonly
+          references
+          reorder
+          reverse_order
+          select
+          distinct
+          uniq
+          where].include?(m.to_s)
+      end
+
+    end
+
+  end
+end

data/lib/arel_converter/translators/scope.rb

@@ -0,0 +1,28 @@
+module ArelConverter
+  module Translator
+    class Scope < Base
+
+      def process_call(exp)
+        @options = Options.translate(exp.pop) if exp[1] == :scope
+        super
+      end
+
+      def post_processing(new_scope)
+        new_scope.gsub!(/scope\((.*)\)$/, 'scope \1')
+        new_scope += format_options(@options)
+      end
+
+    protected
+
+      def format_options(options)
+        return if options.nil? || options.empty?
+        ", " + (includes_lambda?(options) ? options : "-> { #{options.strip} }")
+      end
+
+      def includes_lambda?(source)
+        source.include?('lambda') || source.include?('->')
+      end
+
+    end
+  end
+end

data/lib/arel_converter/version.rb

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

data/spec/fixtures/grep_matching.rb

@@ -0,0 +1,38 @@
+class GrepMatching # < ActiveRecord::Base
+
+  # Associations
+  has_many :posts
+  has_and_belongs_to_many :articles
+  has_one :author
+  belongs_to :blog
+
+  def mystery_method
+    has_many = 'Test cases'
+  end
+
+  # Scopes
+  scope :active, :conditions => ['status NOT IN (?)', ['closed','cancelled']]
+
+  # this comment on scope should not show show up
+  def scoping
+    scope = 'My Scope'
+  end
+
+  # Finders
+  def finder_calls
+    Model.find(:all)
+
+    Model.find(:first)
+
+    Model.find(:all, :conditions => {:active => true})
+
+    Model.all(:conditions => {:active => false})
+
+    Model.first(:conditions => {:active => false})
+
+    # should not be found
+    Model.all
+    Model.first
+  end
+
+end