arel_converter 0.0.1

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

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe ArelConverter::Translator::Options do
+
+  context 'parsing ActiveRecord options' do
+
+    context 'as a S-Expression' do
+      it 'should work with the same results as a string' do
+        code_fragment = %Q{{:joins => :roles}}
+        sexp = RubyParser.new.process(code_fragment)
+        expect(ArelConverter::Translator::Options.translate(sexp)).to eq(ArelConverter::Translator::Options.translate(code_fragment))
+      end
+    end
+
+    context 'as a string' do
+
+      context 'with joins' do
+        it 'when it is a simple association' do
+          scope = %Q{{:joins => :roles}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{joins(:roles)})
+        end
+
+        it 'when it is an array of simple associations' do
+          scope = %Q{{:joins => [:roles, :users]}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{joins(:roles, :users)})
+        end
+
+        it 'when it is a SQL fragment' do
+          scope = %Q{{:joins => "LEFT JOIN `roles` ON roles.scope_id = scopes.id"}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{joins("LEFT JOIN `roles` ON roles.scope_id = scopes.id")})
+        end
+
+        it 'when it is a hash of associations' do
+          scope = %Q{{:joins => {:roles => :users}}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{joins( roles: :users )})
+        end
+      end
+
+      context 'with includes' do
+        it 'when it is a simple association' do
+          scope = %Q{{:include => :roles}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{includes(:roles)})
+        end
+
+        it 'when it is an array of simple associations' do
+          scope = %Q{{:include => [:roles, :users]}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{includes(:roles, :users)})
+        end
+
+        it 'when it is a hash of associations' do
+          scope = %Q{{:include => {:roles => :users}}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{includes( roles: :users )})
+        end
+      end
+
+      context 'with conditions' do
+        it 'when they are a string' do
+          scope = %Q{{:conditions => "active = 1"}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{where("active = 1")})
+        end
+
+        it 'when they are an array' do
+          scope = %Q{{:conditions => ["active = ?", true]}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{where("active = ?", true)})
+        end
+
+        it 'where they are a single hash' do
+          scope = %Q{{:conditions => {:active => 1}}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{where( active: 1 )})
+        end
+
+        it 'where they are a hash' do
+          scope = %Q{{:conditions => {:active => 1, :name => 'John'}}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{where( active: 1, name: "John" )})
+        end
+
+        it 'where there is a hash including an array' do
+          scope = %Q{{:conditions => {:state => ['confirmed', 'partially_received', 'ordered']}}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{where( state: ["confirmed", "partially_received", "ordered"] )})
+        end
+
+        it 'where there is a where and include' do
+          scope = %Q{{:include => :purchase_order, :conditions => ["purchase_orders.state NOT IN ('shopping', 'received', 'cancelled', 'closed')"]}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{includes(:purchase_order).where("purchase_orders.state NOT IN ('shopping', 'received', 'cancelled', 'closed')")})
+        end
+      end
+
+      context "with lambdas" do
+        it 'should stay on a single line' do
+          scope = %Q{lambda{|vendor| {:include => :vendor_purchase_order, :conditions => ["purchase_orders.vendor_id = ?", vendor.id]}}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{lambda { |vendor| includes(:vendor_purchase_order).where("purchase_orders.vendor_id = ?", vendor.id) }})
+        end
+      end
+
+      context "with multiple options" do
+        it 'should concatinate them correctly' do
+          scope = %Q{{:include => [:vendor], :conditions => "state IN ('confirmed','partially_received')"}}
+          expect(ArelConverter::Translator::Options.translate(scope)).to eq(%Q{includes(:vendor).where("state IN ('confirmed','partially_received')")})
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe ArelConverter::Translator::Scope do
+
+  context 'parsing scopes' do
+
+    context 'with joins' do
+      it 'when it is a simple association' do
+        scope = %Q{scope :my_scope, :joins => :roles}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { joins(:roles) }})
+      end
+
+      it 'when it is an array of simple associations' do
+        scope = %Q{scope :my_scope, :joins => [:roles, :users]}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { joins(:roles, :users) }})
+      end
+
+      it 'when it is a SQL fragment' do
+        scope = %Q{scope :my_scope, :joins => "LEFT JOIN `roles` ON roles.scope_id = scopes.id"}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { joins("LEFT JOIN `roles` ON roles.scope_id = scopes.id") }})
+      end
+
+      it 'when it is a hash of associations' do
+        scope = %Q{scope :my_scope, :joins => {:roles => :users}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { joins( roles: :users ) }})
+      end
+    end
+
+    context 'with includes' do
+      it 'when it is a simple association' do
+        scope = %Q{scope :my_scope, :include => :roles}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes(:roles) }})
+      end
+
+      it 'when it is an array of simple associations' do
+        scope = %Q{scope :my_scope, :include => [:roles, :users]}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes(:roles, :users) }})
+      end
+
+      it 'when it is a hash of associations' do
+        scope = %Q{scope :my_scope, :include => {:roles => :users}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes( roles: :users ) }})
+      end
+
+      it 'when there is a nested hash of associations' do
+        scope = %Q{scope :my_scope, :include => [:author => {:roles => :users}]}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes( author: { roles: :users } ) }})
+      end
+
+      it 'when there is an array of associations with a nested hash of' do
+        scope = %Q{scope :my_scope, :include => [ {:strengths => :unit}, :origin_country, :unit]}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes({ strengths: :unit }, :origin_country, :unit) }})
+      end
+    end
+
+    context 'with conditions' do
+      it 'when they are a string' do
+        scope = %Q{scope :my_scope, :conditions => "active = 1"}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { where("active = 1") }})
+      end
+
+      it 'when they are an array' do
+        scope = %Q{scope :my_scope, :conditions => ["active = ?", true]}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { where("active = ?", true) }})
+      end
+
+      it 'where they are a single hash' do
+        scope = %Q{scope :my_scope, :conditions => {:active => 1}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { where( active: 1 ) }})
+      end
+
+      it 'where they are a hash' do
+        scope = %Q{scope :my_scope, :conditions => {:active => 1, :name => 'John'}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { where( active: 1, name: "John" ) }})
+      end
+
+      it 'where there is a hash including an array' do
+        scope = %Q{scope :my_scope, :conditions => {:state => ['confirmed', 'partially_received', 'ordered']}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { where( state: ["confirmed", "partially_received", "ordered"] ) }})
+      end
+
+      it 'where there is a where and include' do
+        scope = %Q{scope :my_scope, :include => :purchase_order, :conditions => ["purchase_orders.state NOT IN ('shopping', 'received', 'cancelled', 'closed')"]}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes(:purchase_order).where("purchase_orders.state NOT IN ('shopping', 'received', 'cancelled', 'closed')") }})
+      end
+
+      it 'where there is a hash with string keys' do
+        scope = %Q{scope :my_scope, :conditions => {'products.generic' => true}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { where( "products.generic" => true ) }})
+      end
+    end
+
+    context "with lambdas" do
+      it 'should handle stubby lambdas' do
+        scope = %Q{scope :for_state, -> { where(:state => state.to_s.upcase) }}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :for_state, -> { where(state: state.to_s.upcase) }})
+      end
+
+      it 'should not change an existing Arel call (very much)' do
+        scope = %Q{scope :for_state, lambda {|state| where(:state => state.to_s.upcase) }}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :for_state, lambda { |state| where(state: state.to_s.upcase) }})
+      end
+      it 'should not change existing chained Arel calls (very much)' do
+        scope = %Q{scope :for_state, lambda {|state| where(:state => state.to_s.upcase).order(:name) }}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :for_state, lambda { |state| where(state: state.to_s.upcase).order(:name) }})
+      end
+
+      it 'should stay on a single line' do
+        scope = %Q{scope :my_scope, lambda{|vendor| {:include => :vendor_purchase_order, :conditions => ["purchase_orders.vendor_id = ?", vendor.id]}}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, lambda { |vendor| includes(:vendor_purchase_order).where("purchase_orders.vendor_id = ?", vendor.id) }})
+      end
+
+      it 'should parse when a conditional is present' do
+        scope = %Q{scope :my_scope, lambda{|search_term| {:conditions => ["posts.name LIKE ?", "%\#{search_term}%"]} unless search_term.blank? }}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, lambda { |search_term| where("posts.name LIKE ?", "%\#{search_term}%") unless search_term.blank? }})
+      end
+    end
+
+    context "with multiple options" do
+      it 'should concatinate them correctly' do
+        scope = %Q{scope :my_scope, {:include => [:vendor], :conditions => "state IN ('confirmed','partially_received')"}}
+        expect(ArelConverter::Translator::Scope.translate(scope)).to eq(%Q{scope :my_scope, -> { includes(:vendor).where("state IN ('confirmed','partially_received')") }})
+      end
+    end
+
+  end
+
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'arel_converter'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: arel_converter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Peer Allan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby2ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Converts existing AR finder syntax to AREL
+email:
+- peer.allan@canadadrugs.com
+executables:
+- arel_convert
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- arel_converter.gemspec
+- bin/arel_convert
+- lib/arel_converter.rb
+- lib/arel_converter/active_record_finder.rb
+- lib/arel_converter/association.rb
+- lib/arel_converter/base.rb
+- lib/arel_converter/command.rb
+- lib/arel_converter/formatter.rb
+- lib/arel_converter/replacement.rb
+- lib/arel_converter/scope.rb
+- lib/arel_converter/translators/association.rb
+- lib/arel_converter/translators/base.rb
+- lib/arel_converter/translators/finder.rb
+- lib/arel_converter/translators/options.rb
+- lib/arel_converter/translators/scope.rb
+- lib/arel_converter/version.rb
+- spec/fixtures/grep_matching.rb
+- spec/fixtures/my/base_fixture.rb
+- spec/fixtures/my/files/controller.rb
+- spec/fixtures/my/files/model.rb
+- spec/fixtures/my/files/not_source.txt
+- spec/fixtures/my/files/source.rb
+- spec/lib/arel_converter/active_record_finder_spec.rb
+- spec/lib/arel_converter/association_spec.rb
+- spec/lib/arel_converter/base_spec.rb
+- spec/lib/arel_converter/command_spec.rb
+- spec/lib/arel_converter/replacement_spec.rb
+- spec/lib/arel_converter/scope_spec.rb
+- spec/lib/arel_converter/translators/association_spec.rb
+- spec/lib/arel_converter/translators/finder_spec.rb
+- spec/lib/arel_converter/translators/options_spec.rb
+- spec/lib/arel_converter/translators/scope_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Converts AR finders, scopes and association arguments to AREL syntax
+test_files:
+- spec/fixtures/grep_matching.rb
+- spec/fixtures/my/base_fixture.rb
+- spec/fixtures/my/files/controller.rb
+- spec/fixtures/my/files/model.rb
+- spec/fixtures/my/files/not_source.txt
+- spec/fixtures/my/files/source.rb
+- spec/lib/arel_converter/active_record_finder_spec.rb
+- spec/lib/arel_converter/association_spec.rb
+- spec/lib/arel_converter/base_spec.rb
+- spec/lib/arel_converter/command_spec.rb
+- spec/lib/arel_converter/replacement_spec.rb
+- spec/lib/arel_converter/scope_spec.rb
+- spec/lib/arel_converter/translators/association_spec.rb
+- spec/lib/arel_converter/translators/finder_spec.rb
+- spec/lib/arel_converter/translators/options_spec.rb
+- spec/lib/arel_converter/translators/scope_spec.rb
+- spec/spec_helper.rb