arel_converter 0.0.1

data/spec/lib/arel_converter/active_record_finder_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe ArelConverter::ActiveRecordFinder do
+
+  let(:converter) { ArelConverter::ActiveRecordFinder.new('spec/fixtures/grep_matching.rb') }
+
+  let(:valid_lines) { ["    Model.find(:all)", "    Model.find(:all, :conditions => {:active => true})", "    Model.find(:first)", "    Model.find(:all, :conditions => {:active => true})", "    Model.all(:conditions => {:active => false})", "    Model.first(:conditions => {:active => false})"] }
+
+  it 'should find all the valid lines from a file' do
+    expect(converter.grep_matches_in_file('spec/fixtures/grep_matching.rb')).to eq(valid_lines)
+  end
+
+  describe '#process_lines' do
+    it 'should pass of translation to the ActiveRecordFinder translator' do
+      expect(ArelConverter::Translator::Finder).to receive(:translate).with('MyModel.find(:all)').and_return('scope(:active)')
+      converter.process_line('MyModel.find(:all)')
+    end
+
+    it 'should remove surrounding brackets for clarity' do
+      allow(ArelConverter::Translator::Finder).to receive(:translate).and_return('translated line')
+      expect(converter.process_line('MyModel.find(:all)')).to eq('translated line')
+    end
+  end
+
+end
+

data/spec/lib/arel_converter/association_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe ArelConverter::Association do
+
+  let(:converter) { ArelConverter::Association.new('spec/fixtures/grep_matching.rb') }
+
+  let(:valid_lines) { ["  has_many :posts", "  has_and_belongs_to_many :articles", "  has_one :author", "  belongs_to :blog"] }
+  let(:invalid_lines) { ["    has_many = 'Test cases'"] }
+  let(:all_lines) { valid_lines + invalid_lines }
+
+  it 'should find all the valid lines from a file' do
+    expect(converter.grep_matches_in_file('spec/fixtures/grep_matching.rb')).to eq(all_lines)
+  end
+
+  describe 'verify lines' do
+    it 'should know of valid lines' do
+      valid_lines.each do |l|
+        expect(converter.verify_line(l)).to be_true
+      end
+    end
+
+    it 'should know of invalid lines' do
+      invalid_lines.each do |l|
+        expect(converter.verify_line(l)).to be_false
+      end
+    end
+  end
+
+  describe '#process_lines' do
+    it 'should pass of translation to the Association translator' do
+      expect(ArelConverter::Translator::Association).to receive(:translate).with('my line')
+      converter.process_line('my line')
+    end
+  end
+
+end

data/spec/lib/arel_converter/base_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe ArelConverter::Base do
+
+
+  let(:converter) { ArelConverter::Base.new('.') }
+  let(:file_converter) { ArelConverter::Base.new('spec/fixtures/my/files/source.rb') }
+  let(:dir_converter)  { ArelConverter::Base.new('spec/fixtures/my') }
+
+  let(:replacement_good) { ArelConverter::Replacement.new('Good Line', 'PROCESSED') }
+  let(:replacemetn_bad) { ArelConverter::Replacement.new('Pretty Line', 'PROCESSED') }
+  let(:replacement_error) { 
+    r = ArelConverter::Replacement.new('Invalid Line')
+    r.error = "This is no good!"
+    r
+  }
+  let(:replacements) { [replacement_good, replacemetn_bad] }
+  let(:replacements_with_errors) { [replacement_good, replacement_error, replacemetn_bad] }
+
+  describe 'executes against the proper type' do
+    it 'should execute against a single file' do
+      expect(file_converter).to receive(:parse_file).with('spec/fixtures/my/files/source.rb')
+      expect(file_converter).not_to receive(:parse_directory)
+      file_converter.run!
+    end
+
+    it 'should execute against a directory' do
+      expect(dir_converter).to receive(:parse_directory).with('spec/fixtures/my')
+      dir_converter.run!
+    end
+  end
+
+  describe 'executing against a directory' do
+    let(:files) { Dir['spec/fixtures/my/**/*.rb'].map {|file| file } }
+
+    it 'should execute against all ruby files in the supplied directory' do
+      files.each do |f|
+        expect(dir_converter).to receive(:parse_file).with(f)
+      end
+      dir_converter.run!
+    end
+  end
+
+  describe 'parsing a file' do
+
+    let(:matched_lines) { ['a','b'] }
+    let(:results) { ['result 1', 'result 2'] }
+
+    before do
+      file_converter.stub(:update_file)
+      allow(file_converter).to receive(:grep_matches_in_file).and_return(matched_lines)
+      allow(file_converter).to receive(:process_lines).with(matched_lines).and_return(results)
+      allow(ArelConverter::Formatter).to receive(:alert)
+    end
+
+    it "should grep the file for matches and do nothing if there are none" do
+      expect(file_converter).to receive(:grep_matches_in_file).and_return([])
+      expect(file_converter).to_not receive(:process_lines)
+      file_converter.run!
+    end
+
+    it 'should process any lines that are found' do
+      expect(file_converter).to receive(:grep_matches_in_file).and_return(matched_lines)
+      expect(file_converter).to receive(:process_lines).with(matched_lines).and_return([])
+      file_converter.run!
+    end
+
+    it 'should pass to the formatter any results' do
+      expect(ArelConverter::Formatter).to receive(:alert).with('spec/fixtures/my/files/source.rb',results)
+      file_converter.run!
+    end
+
+    it 'should update the file' do
+      allow(file_converter).to receive(:process_lines).with(matched_lines).and_return(results)
+      expect(file_converter).to receive(:update_file).with('spec/fixtures/my/files/source.rb',results)
+      file_converter.run!
+    end
+
+    it 'should not update the files if configured not to' do
+      allow(file_converter).to receive(:process_lines).with(matched_lines).and_return(results)
+      expect(ArelConverter::Formatter).to receive(:alert)
+      expect(file_converter).to_not receive(:update_file)
+      file_converter.options[:dry_run] = true
+      file_converter.run!
+    end
+
+    it 'should not output or update if there are no results' do
+      allow(file_converter).to receive(:process_lines).and_return([])
+      expect(ArelConverter::Formatter).to_not receive(:alert)
+      expect(file_converter).to_not receive(:update_file)
+      file_converter.run!
+    end
+
+  end
+
+  describe 'processing lines' do
+    let(:lines) { ['Good Line', 'Invalid Line', 'Pretty Line'] }
+
+    before do
+      allow(converter).to receive(:process_line).and_return('PROCESSED')
+    end
+
+    it 'should return only lines that are valid ' do
+      allow(converter).to receive(:verify_line).and_return(true, false, true)
+      expect(converter.process_lines(lines)).to eq(replacements)
+    end
+
+    it 'should return only lines that do not raise a SyntaxError' do
+      allow(converter).to receive(:process_line).with('Invalid Line').and_raise(SyntaxError)
+      expect(converter.process_lines(lines)).to eq(replacements_with_errors)
+    end
+
+    it 'should only return lines that do not raise other exceptions' do
+      allow(converter).to receive(:process_line).with('Invalid Line').and_raise(RuntimeError)
+      expect(converter.process_lines(lines)).to eq(replacements_with_errors)
+    end
+  end
+
+  describe 'updating files' do
+
+    it 'should do replacement on the proper lines' do
+      file_handle = double
+      allow(File).to receive(:read).and_return("Good Line\n\nNext Line\n\nThird Line\n\nPretty Line")
+      expect(File).to receive(:open).and_yield(file_handle)
+      expect(file_handle).to receive(:puts).with("PROCESSED\n\nNext Line\n\nThird Line\n\nPROCESSED")
+      converter.update_file('my/file.rb', replacements_with_errors)
+    end
+
+  end
+end

data/spec/lib/arel_converter/command_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ArelConverter::Command do
+
+  it 'needs to be tested'
+
+end

data/spec/lib/arel_converter/replacement_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe ArelConverter::Replacement do
+  let(:r) { ArelConverter::Replacement.new('old', 'new') }
+
+  it 'should initialize correctly' do
+    expect(r.old_content).to eq('old')
+    expect(r.new_content).to eq('new')
+  end
+
+  it 'should be valid if error is nil' do
+    r.error = nil
+    expect(r).to be_valid
+  end
+
+  it 'should be invalid if error is set' do
+    r.error = 'Some Random Error'
+    expect(r).not_to be_valid
+  end
+end
+
+

data/spec/lib/arel_converter/scope_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ArelConverter::Scope do
+
+  let(:converter) { ArelConverter::Scope.new('spec/fixtures/grep_matching.rb') }
+
+  let(:valid_lines) { ["  scope :active, :conditions => ['status NOT IN (?)', ['closed','cancelled']]"] }
+  let(:invalid_lines) { ["    scope = 'Test cases'"] }
+
+  it 'should find all the valid lines from a file' do
+    expect(converter.grep_matches_in_file('spec/fixtures/grep_matching.rb')).to eq(valid_lines)
+  end
+
+  describe 'verify lines' do
+    it 'should know of valid lines' do
+      valid_lines.each do |l|
+        expect(converter.verify_line(l)).to be_true
+      end
+    end
+
+    it 'should know of invalid lines' do
+      invalid_lines.each do |l|
+        expect(converter.verify_line(l)).to be_false
+      end
+    end
+  end
+
+  describe '#process_lines' do
+    it 'should pass of translation to the Scope translator' do
+      expect(ArelConverter::Translator::Scope).to receive(:translate).with('scope :active').and_return('scope(:active)')
+      converter.process_line('scope :active')
+    end
+
+    it 'should remove surrounding brackets for clarity' do
+      allow(ArelConverter::Translator::Scope).to receive(:translate).and_return('scope(:active)')
+      expect(converter.process_line('scope :active')).to eq('scope :active')
+    end
+  end
+
+end

data/spec/lib/arel_converter/translators/association_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe ArelConverter::Translator::Association do
+
+  context 'parsing belongs_to' do
+    it 'should not change if there are no options' do
+      assoc = %Q{belongs_to :post}
+      expect(ArelConverter::Translator::Association.translate(assoc)).to eq(%Q{belongs_to :post})
+    end
+
+    it 'should translate the options' do
+      assoc = %Q{belongs_to :post, :class_name => "Article", :foreign_key => "article_id"}
+      expect(ArelConverter::Translator::Association.translate(assoc)).to eq(%Q{belongs_to :post, class_name: "Article", foreign_key: "article_id"})
+    end
+
+    it 'should translate polymorphic correctly' do
+      assoc = %Q{belongs_to :post, :polymorphic => true}
+      expect(ArelConverter::Translator::Association.translate(assoc)).to eq(%Q{belongs_to :post, polymorphic: true})
+    end
+  end
+
+  context 'parsing has_and_belongs_to_many' do
+
+    it 'should not change if there are no options' do
+      finder = %Q{has_and_belongs_to_many :posts}
+      expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_and_belongs_to_many :posts})
+    end
+
+    it 'should translate options' do
+      finder = %Q{has_and_belongs_to_many :posts, :uniq => true}
+      expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_and_belongs_to_many :posts, -> { uniq(true) }})
+    end
+
+  end
+
+
+  context 'parsing has_one' do
+    it 'should ignore if no options set' do
+      finder = %Q{has_one :posts}
+      expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_one :posts})
+    end
+
+    it 'should translate options' do
+      finder = %Q{has_one :posts, :conditions => ['posts.active = ?', true]}
+      expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_one :posts, -> { where("posts.active = ?", true) }})
+    end
+
+    context 'with options' do
+
+      %w[as autosave class_name dependent foreign_key inverse_of 
+         primary_key source source_type through validate].each do |option|
+
+        it "should handle the #{option} option" do
+          finder = %Q{has_one :posts, :#{option} => 'Sheet'}
+          expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_one :posts, #{option}: "Sheet"})
+        end
+
+        it "such as #{option} with scoping" do
+          finder = %Q{has_one :posts, :#{option} => 'Sheet', :conditions => ['posts.active = ?', true]}
+          expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_one :posts, -> { where("posts.active = ?", true) }, #{option}: "Sheet"})
+        end
+
+      end
+
+      it 'should handle multiple options' do
+        finder = %Q{has_one :posts, :as => 'Sheet', :through => :roles}
+        expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_one :posts, as: "Sheet", through: :roles})
+      end
+    end
+  end
+
+
+  context 'parsing has_many' do
+    it 'should ignore if no options set' do
+      finder = %Q{has_many :posts}
+      expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_many :posts})
+    end
+
+    it 'should translate options' do
+      finder = %Q{has_many :posts, :conditions => ['posts.active = ?', true]}
+      expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_many :posts, -> { where("posts.active = ?", true) }})
+    end
+
+    context 'with options' do
+
+      %w[as autosave class_name dependent foreign_key inverse_of 
+         primary_key source source_type through validate].each do |option|
+
+        it "should handle the #{option} option" do
+          finder = %Q{has_many :posts, :#{option} => 'Sheet'}
+          expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_many :posts, #{option}: "Sheet"})
+        end
+
+        it "such as #{option} with scoping" do
+          finder = %Q{has_many :posts, :#{option} => 'Sheet', :conditions => ['posts.active = ?', true]}
+          expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_many :posts, -> { where("posts.active = ?", true) }, #{option}: "Sheet"})
+        end
+
+      end
+
+      it 'should handle multiple options' do
+        finder = %Q{has_many :posts, :as => 'Sheet', :through => :roles}
+        expect(ArelConverter::Translator::Association.translate(finder)).to eq(%Q{has_many :posts, as: "Sheet", through: :roles})
+      end
+    end
+
+  end
+
+end
+

data/spec/lib/arel_converter/translators/finder_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ArelConverter::Translator::Finder do
+
+  context 'parsing .all' do
+    it 'as a model method with no arguments' do
+      finder = %Q{MyModel.all}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.all})
+    end
+
+    it 'as a model method' do
+      finder = %Q{MyModel.all(:joins => [:payment_method], :conditions => ["payment_methodable_type = 'ChequePaymentMethod' AND amount > 0"])}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.joins(:payment_method).where("payment_methodable_type = 'ChequePaymentMethod' AND amount > 0")})
+    end
+
+    it 'as a chained method' do
+      finder = %Q{self.payments.all(:joins => [:payment_method], :conditions => ["payment_methodable_type = 'ChequePaymentMethod' AND amount > 0"])}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{self.payments.joins(:payment_method).where("payment_methodable_type = 'ChequePaymentMethod' AND amount > 0")})
+    end
+  end
+
+  context 'parsing .first' do
+    it 'as a model method with no arguments' do
+      finder = %Q{MyModel.first}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.first})
+    end
+
+    it 'as a model method' do
+      finder = %Q{MyModel.first(:joins => [:payment_method], :conditions => ["payment_methodable_type = 'ChequePaymentMethod' AND amount > 0"])}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.joins(:payment_method).where("payment_methodable_type = 'ChequePaymentMethod' AND amount > 0").first})
+    end
+
+    it 'as a chained method' do
+      finder = %Q{self.payments.first(:joins => [:payment_method], :conditions => ["payment_methodable_type = 'ChequePaymentMethod' AND amount > 0"])}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{self.payments.joins(:payment_method).where("payment_methodable_type = 'ChequePaymentMethod' AND amount > 0").first})
+    end
+
+    it '' do
+      finder = %Q{MyModel.first(:conditions=> conditions_array, :order => "tickets.weight desc, tickets.sort_date asc", :include => INCLUDE, :joins => joins)}
+      expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.where(conditions_array).order("tickets.weight desc, tickets.sort_date asc").includes(INCLUDE).joins(joins).first})
+    end
+  end
+
+
+  context 'parsing #find' do
+
+    context 'with the :first argument' do
+
+      it 'without conditions in a model' do
+        finder = %Q{MyModel.find(:first)}
+        expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.first})
+      end
+
+      it 'without conditions in a model' do
+        finder = %Q{MyModel.find(:first, :order => 'created_at DESC', :conditions => "active = 1")}
+        expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{MyModel.order("created_at DESC").where("active = 1").first})
+      end
+
+      it 'without conditions' do
+        finder = %Q{self.payment_optimizations.find(:first)}
+        expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{self.payment_optimizations.first})
+      end
+
+      it 'with a single condition' do 
+        finder = %Q{self.payment_optimizations.find(:first, :order => 'created_at DESC')}
+        expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{self.payment_optimizations.order("created_at DESC").first})
+      end
+
+      it 'with conditions' do
+        finder = %Q{self.payment_optimizations.find(:first, :order => 'created_at DESC', :conditions => "active = 1")}
+        expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{self.payment_optimizations.order("created_at DESC").where("active = 1").first})
+      end
+
+    end
+
+    context 'with the :all argument' do
+      it 'should not append .all' do
+        finder = %Q{self.find(:all, :select => "DISTINCT(sales_channels.name)").map(&:name)}
+        expect(ArelConverter::Translator::Finder.translate(finder)).to eq(%Q{self.select("DISTINCT(sales_channels.name)").map(&:name)})
+      end
+    end
+
+  end
+
+end
+
+
+