linqr 0.1.0

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rspec", "~> 2.4.0"
+end

data/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rspec (~> 2.4.0)

data/README.rdoc

@@ -0,0 +1,90 @@
+= Linqr - Query Comprehensions for Ruby
+
+Linq ( http://msdn.microsoft.com/en-us/vcsharp/aa336746 )like sytax for ruby.
+
+Linq in C# is a great example of bringing a uniform query model to
+different sources of Data. Different providers can be hooked into the
+model so developers can still use the familiar sytax to query the data
+source instead of learning a whole new api.
+
+
+== Usage
+
+=== Querying enumerable
+* Quering an array
+
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    output =  _{ 
+      from x
+      in_ numbers
+      where (x == 3 ||  x == 5 || x == 8) && ( x % 2) == 0
+      select x * 3
+    }
+    output.should == [24]
+
+* Quering a hash
+
+    hash = {:a => 1 , :b => 2 , :c => 3}
+    output = _{
+      from k,v
+      in_ hash
+      where v == 3
+      select k
+    }
+   output.should == [:c]
+
+* Grouping(select can select into anonymous types)
+
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    number_groups = _{
+      from n 
+      in_ numbers
+      where n > 3 && n < 100
+      group_by n % 5  => :g
+      select :remainder => g.key , :values => g.values
+    }
+    number_groups.collect(&:remainder).should == [0, 4, 1, 3, 2]
+
+* Ordering 
+
+    words = [ "cherry", "apple", "blueberry" ]
+    sorted_words = _{
+      from word 
+      in_ words
+      order_by word.length
+      select word
+    }
+    sorted_words.should == ["apple", "cherry", "blueberry"]
+* Selecting into anonymous types
+
+    products = [Product.new("shoes", 1.75), Product.new("glasses", 55.55), Product.new("pencil", 5.20)]
+    
+    cheap_product_names = _{
+      from p
+      in_ products 
+      where p.price < 10
+      select :name => "Cheap - #{p.name}" , :new_price => p.price + 10
+    }
+    
+    cheap_product_names.collect(&:name).should == ["Cheap - shoes","Cheap - pencil"]
+    cheap_product_names.collect(&:new_price).should == [11.75, 15.20]
+
+=== Querying ActiveRecord Models
+ All the examples listed for enumerable should work with activerecord models too
+
+    grouped_by_name = _{
+        from o 
+        in_ Order
+        order_by o.name
+        group_by o.name   => :g
+        select :name => g.key , :orders => g.values
+      }
+
+=== Querying Groupon Api
+    output =  _{·
+      from deal
+      in_  GrouponDeals
+      where deal.lat == 38.8339 && deal.lng == -104.821·
+      select deal
+    }
+

data/Rakefile

@@ -0,0 +1,52 @@
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "linqr"
+  gem.homepage = "http://github.com/suryagaddipati/linqr"
+  gem.license = "MIT"
+  gem.summary = %Q{Query Comprehensions for ruby}
+  gem.description = %Q{Linq like sytax for querying multiple-datasources}
+  gem.email = "surya.gaddipati@gmail.com"
+  gem.authors = ["surya"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = ["./spec/**/*_spec.rb","./examples/**/*_spec.rb"]
+end
+     
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.pattern = ["./spec/**/*_spec.rb","./examples/**/*_spec.rb"]
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "linqr #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/examples/linqr2enumerable/ordering_operators_spec.rb

@@ -0,0 +1,54 @@
+require 'linqr'
+require 'spec_helper'
+describe "order by" do
+  Item = Struct.new(:name , :price, :discount_price)
+  it "should order by the order by operator" do
+    words = [ "cherry", "apple", "blueberry" ]
+    sorted_words = __{
+      from word in_ words order_by word
+      select word
+    }
+    sorted_words.should ==  ["apple", "blueberry","cherry" ]
+  end
+
+  it "simple-2" do
+    words = [ "cherry", "apple", "blueberry" ]
+    sorted_words = __{
+      from word 
+      in_ words
+      order_by word.length
+      select word
+    }
+    sorted_words.should == ["apple", "cherry", "blueberry"]
+  end
+  
+  it "descending" do
+    doubles = [ 1.7, 2.3, 1.9, 4.1, 2.9 ]
+    desc_doubles = __{
+      from d 
+      in_ doubles
+      order_by  d => descending
+      select d
+    }
+    desc_doubles.should == [4.1, 2.9, 2.3, 1.9, 1.7]
+  end
+  it "then-by-descending" do
+    products = [Item.new("bag", 9.00,5.00),Item.new("shoes", 5.00,2.00), Item.new("apple", 5.00,4.00), Item.new("cup", 25.00,14.00)]
+     __{
+      from p 
+      in_ products
+      order_by  p.price, p.discount_price
+      select p
+    }.collect(&:name).should == ["shoes","apple", "bag", "cup"] 
+  end
+
+  it "then-by" do
+    products = [Item.new("bag", 9.00,5.00),Item.new("apple", 5.00,2.00), Item.new("shoes", 5.00,4.00), Item.new("cup", 25.00,5.00)]
+     __{
+      from p 
+      in_ products
+      order_by  p.price, p.discount_price => descending
+      select p
+    }.collect(&:name).should == ["cup","bag","shoes","apple"] 
+  end
+end

data/examples/linqr2enumerable/projection_operators_spec.rb

@@ -0,0 +1,54 @@
+require 'linqr'
+describe "Projection operators" do
+  it "Simple 1" do 
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    output =  _{ 
+      from n
+      in_ numbers
+      select n + 1
+    }.to_a
+    output.should == [6, 5, 2, 4, 10, 9, 7, 8, 3, 1]
+  end
+
+  it  "Simple 2" do
+    Product = Struct.new(:name, :price)
+    products = [Product.new("shoes", 1.75), Product.new("glasses", 55.55), Product.new("pencil", 5.20)]
+    
+    product_names = _{
+      from p
+      in_ products 
+      select p.name
+    }.to_a
+    product_names.should == ["shoes","glasses","pencil"]
+  end
+
+  it  "Select - Transformation" do
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    strings = [ "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" ]
+    text_nums = _{
+      from n
+      in_ numbers
+      select strings[n]
+    }.to_a
+    text_nums.should == ["five", "four", "one", "three", "nine", "eight", "six", "seven", "two", "zero"]
+  end
+  it "should return a thunk" do
+    natural_numbers = Enumerator.new do |yielder|
+      number = 1
+      loop do
+        yielder.yield number
+        number += 1
+      end
+    end
+
+    plus_ones = _{
+      from n
+      where n < 5
+      in_ natural_numbers
+      select n 
+    }.take(4)
+    
+   plus_ones.to_a.should == [1,2,3,4] 
+
+  end
+end

data/lib/expression_evaluator_base.rb

@@ -0,0 +1,45 @@
+class ExpressionEvaluator
+
+  def initialize(linq_exp)
+    @linq_exp = linq_exp
+  end
+
+  def visit_symbol(node)
+    node.value
+  end
+
+  def visit_variable(node)
+    @linq_exp.variable_val(node.to_s)
+  end
+
+  def visit_integer(node)
+    node.value
+  end
+
+  def visit_float(node)
+    node.value
+  end
+  def visit_unary(node)
+    target = node.operand.visit(self)
+    target.send("#{node.operator.to_s}@")
+  end
+  def visit_arg(node)
+    node.arg.visit(self)
+  end
+  def visit_string(node)
+    output = ""
+    node.each do |e|
+      output << e.visit(self)
+    end
+    output
+  end
+  
+  def visit_stringcontent(node)
+    node.to_s
+  end
+
+  def visit_statements(node)
+    binary_exp = node.elements.first
+    binary_exp.visit(self)
+  end
+end

data/lib/group_by.rb

@@ -0,0 +1 @@
+Grouped = Struct.new(:key,:values)

data/lib/lazy_enumerator.rb

@@ -0,0 +1,31 @@
+class Enumerator 
+
+  def lazy_sort_by(&block)
+    Enumerator.new do |yielder|
+      index = 0
+      sorted = sort_by(&block)
+      loop do
+        yielder.yield sorted[index]
+        index += 1
+        break if sorted.size == index
+      end
+    end
+  end
+
+  def lazy_select(&block)
+    Enumerator.new do |yielder| 
+      self.each do |val| 
+        yielder.yield(val) if block.call(val) 
+      end
+    end
+  end
+
+  def lazy_map(&block)
+    Enumerator.new do |yielder| 
+      self.each do |value| 
+        yielder.yield(block.call(value))
+      end
+    end
+  end
+end
+

data/lib/linqr.rb

@@ -0,0 +1,55 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+require 'providers/enumerable_provider'
+require 'providers/hash_provider'
+require 'linqr_exp'
+require 'ripper2ruby'
+class Ruby::Node
+  def visit(visitor)
+    class_name=self.class.name.split('::').size == 2 ? self.class.name.split('::')[1]: self.class.name
+    visitor.send("visit_#{class_name.downcase}".to_sym, self)
+  end
+  def evaluate_source_name(visitor)
+    visitor.send("source_name_#{self.class.name.split('::')[1].downcase}".to_sym, self)
+  end
+  def to_sym
+    to_ruby.to_sym
+  end
+end
+
+
+class OrderBy
+  def initialize(node)
+    @node = node
+  end
+
+  def expressions
+    descending?? (@node.arguments[0...-1] << last_arg.first.key): @node.arguments
+  end
+
+  def descending?
+    last_arg.is_a? Ruby::Hash
+  end
+
+  def last_arg
+    @node.arguments.last.arg
+  end
+end
+
+class GroupBy < Ruby::Node
+  def initialize(node)
+    @node = node
+  end
+  def expression
+    return @node.arg.first.key if @node.arg.is_a? Ruby::Hash
+    @node
+  end
+  def grouping_var
+    @node.arg.first.value.first.to_sym
+  end
+end
+
+class Object
+  def _(&proc_exp)
+    LinqrExp.new(proc_exp).evaluate
+  end
+end

data/lib/linqr_exp.rb

@@ -0,0 +1,84 @@
+require 'sourcify'
+require 'ripper'
+require 'source_name_evaluator'
+class LinqrExp
+
+ %w(where from select).each do | q |
+   send(:define_method,q.to_sym) { fexp(@exp,q) }
+   send(:define_method,(q+"?").to_sym) {!fcall(@exp,q).nil?}
+ end
+
+ def with_vars
+   @variables ||= {}
+   Proc.new do |args|
+     args= [args] unless args.is_a? Array
+     args.each_with_index do |param, idx|
+       @variables[variables[idx].to_s]= param
+     end
+     yield *args
+   end
+ end
+
+ def set_variable(var,val)
+   @variables ||= {}
+   @variables[var] = val
+ end
+
+ def variable_val(var_name)
+   if (@variables && var = @variables[var_name])
+     var
+   else
+    @binding.eval(var_name)
+   end
+ end
+
+ def group_by
+   GroupBy.new(fexp(@exp,"group_by")) 
+ end
+
+ def group_by?
+   !fcall(@exp,"group_by").nil?
+ end
+
+ def order_by
+   OrderBy.new(fcall(@exp,"order_by")) 
+ end
+
+ def order_by?
+   !fcall(@exp,"order_by").nil?
+ end
+
+
+  attr_reader :binding
+  def initialize(proc_exp)
+    @exp = Ripper::RubyBuilder.build(proc_exp.to_source)
+    @binding = proc_exp.binding
+  end
+
+  def evaluate 
+    source.linqr_provider.evaluate(self)
+  end
+
+  def variable
+    variables.first
+  end
+  def variables
+    fcall(@exp,"from").arguments.collect(&:name)
+  end
+  def fcall(exp, fname)
+    exp.select(Ruby::Call).select {|call|call.identifier &&  call.token == fname}.first
+  end
+
+
+  def fexp(exp, fname)
+    f_arg = fcall(exp,fname).arguments.first
+    f_arg # make this less confusing
+  end
+  def source
+    token =fcall(@exp,"in_").arguments.first
+    source_name = token.evaluate_source_name(SourceNameEvaluator.new)
+    @binding.eval(source_name)
+  end
+
+
+end

data/lib/providers/active_record/active_record_expression_evaluator.rb

@@ -0,0 +1,58 @@
+require 'expression_evaluator_base'
+class ActiveRecordExpressionEvaluator < ExpressionEvaluator
+  attr_reader :conditions
+  def initialize(linq_exp)
+    @binding = linq_exp.binding
+    @conditions = {}
+  end
+
+  def visit_argslist(node)
+    node.first.visit(self)
+  end
+  def visit_variable(node)
+    @binding.eval(node.to_s)
+  end
+
+  def visit_integer(node)
+    node.value
+  end
+
+  def visit_binary(node)
+    right_val = node.right.visit(self)
+    left_val = node.left.visit(self)
+    @conditions[left_val] = right_val
+  end
+
+  def visit_arg(node)
+    node.arg.visit(self)
+  end
+  def visit_string(node)
+    node.value
+  end
+
+  def visit_call(node)
+    call = node.identifier.to_sym
+    return call unless call == :member?
+    target = node.target.visit(self)
+    argument = node.arguments.visit(self)
+    @conditions[argument] = target
+  end
+  def visit_array(node)
+    node.value
+  end
+
+  def visit_statements(node)
+    binary_exp = node.elements.first
+    binary_exp.visit(self)
+  end
+
+end
+
+class ArGroupByExpressionEvaluator < ActiveRecordExpressionEvaluator
+  attr_reader :grouping_var , :group_by
+  def visit_hash(node)
+    @grouping_var = node.first.value.visit(self)
+    @group_by = node.first.key.visit(self)
+    @group_by
+  end
+end

data/lib/providers/active_record/activerecord_provider.rb

@@ -0,0 +1,48 @@
+require 'active_record'
+require 'group_by'
+require 'providers/enumerable_provider'
+require 'providers/active_record/active_record_expression_evaluator'
+class ActiveRecordProvider
+  def initialize(active_record_class)
+    @active_record_class = active_record_class
+  end
+  def evaluate(linq_exp)
+    query_params = {}
+    evaluator = ActiveRecordExpressionEvaluator.new(linq_exp)
+    if (linq_exp.where?)
+      linq_exp.where.visit(evaluator)
+      query_params.merge!(:conditions =>evaluator.conditions)
+    end
+
+    group_by_evaluator = ArGroupByExpressionEvaluator.new(linq_exp)
+    if(linq_exp.group_by?)
+      query_params.merge!(:group =>linq_exp.group_by.visit(group_by_evaluator))
+    end
+    if(linq_exp.order_by?)
+      query_params.merge!(:order =>linq_exp.order_by.visit(evaluator))
+    end
+
+    selected_values = @active_record_class.find(:all,query_params)
+
+    if (linq_exp.group_by?)
+      grouped_values = selected_values.group_by(&group_by_evaluator.group_by)
+      grouped_values.collect do |(k,v)|
+        Object.send(:define_method,group_by_evaluator.grouping_var) { Grouped.new(k,v) }
+      linq_exp.select.visit(EnumerableExpessionEvaluator.new(linq_exp))
+      end
+    else 
+      selected_values.collect do |e|
+        Object.send(:define_method,linq_exp.variable.to_sym) { e }
+        linq_exp.select.visit(EnumerableExpessionEvaluator.new(linq_exp))
+      end
+    end
+  end
+end
+
+class ActiveRecord::Base
+  def self.linqr_provider
+    ActiveRecordProvider.new(self)
+  end
+end
+
+

data/lib/providers/enumerable_expression_evaluator.rb

@@ -0,0 +1,46 @@
+require 'ostruct'
+require 'expression_evaluator_base'
+class EnumerableExpessionEvaluator < ExpressionEvaluator
+
+  def visit_groupby(node)
+    node.expression.visit(self)
+  end
+
+  def visit_hash(node)
+    record = OpenStruct.new
+    node.elements.each do |e|
+      key = e.key.visit(self)
+      value = e.value.visit(self)
+      record.send("#{key.to_s}=".to_sym,value)
+    end
+    record
+  end
+
+  def visit_argslist(node)
+    node.map {|arg| arg.visit(self)}
+  end
+
+  def visit_binary(node)
+    right_val = node.right.visit(self)
+    left_val = node.left.visit(self)
+    if node.operator.to_sym == :and
+      left_val && right_val
+    elsif node.operator.to_sym == :or
+      left_val || right_val
+    else
+      left_val.send(node.operator.to_ruby.to_sym, right_val)
+    end
+  end
+
+  def visit_call(node)
+    target = node.target.visit(self)
+    method_name = node.identifier ? node.identifier.to_sym : :[]
+    if (node.arguments)
+      arguments = node.arguments.collect { |x| x.visit(self) }
+      target.send(method_name, *arguments)
+    else
+      target.send(method_name)
+    end
+  end
+end
+

data/lib/providers/enumerable_provider.rb

@@ -0,0 +1,57 @@
+require 'providers/enumerable_expression_evaluator'
+require 'lazy_enumerator'
+require 'group_by'
+class EnumerableProvider
+  def initialize(enumerable)
+    @enumerable = enumerable.to_enum
+  end
+  def handle_where(linq_exp)
+    evaluator = EnumerableExpessionEvaluator.new(linq_exp)
+      @enumerable.lazy_select(&linq_exp.with_vars do|e|
+        linq_exp.where.visit(evaluator)
+      end)
+  end
+
+  def handle_order_by(linq_exp,filtered_values)
+    order_by = linq_exp.order_by
+    order_by.expressions.reduce(filtered_values) do |values, sort_exp|
+      values.lazy_sort_by(&linq_exp.with_vars do|e| 
+        sort_val = sort_exp.visit(EnumerableExpessionEvaluator.new(linq_exp))
+        order_by.descending?? 1 - sort_val : sort_val
+      end)
+    end
+  end
+
+  def handle_group_by(linq_exp,filtered_values)
+    grouped_values = filtered_values.group_by(&linq_exp.with_vars do |e|
+      linq_exp.group_by.visit(EnumerableExpessionEvaluator.new(linq_exp))
+    end)
+
+    grouped_values.collect do |(k,v)|
+      linq_exp.set_variable(linq_exp.group_by.grouping_var.to_s, Grouped.new(k,v) )
+      linq_exp.select.visit(EnumerableExpessionEvaluator.new(linq_exp))
+    end
+  end
+
+  def handle_select(linq_exp,filtered_values)
+    filtered_values.lazy_map(&linq_exp.with_vars do |e|
+      linq_exp.select.visit(EnumerableExpessionEvaluator.new(linq_exp))
+    end)
+  end
+
+  def evaluate (linq_exp)
+    filtered_values =linq_exp.where?? handle_where(linq_exp) : @enumerable
+    filtered_values = linq_exp.order_by?? handle_order_by(linq_exp,filtered_values) : filtered_values
+    if (linq_exp.group_by?)
+      handle_group_by(linq_exp,filtered_values)
+    else
+      handle_select(linq_exp,filtered_values)
+    end
+  end
+end
+
+module  Enumerable
+  def linqr_provider
+    EnumerableProvider.new(self)
+  end
+end

data/lib/providers/groupon/groupon_provider.rb

@@ -0,0 +1,41 @@
+require 'groupon'
+require 'expression_evaluator_base'
+class GrouponDeals
+
+  def self.linqr_provider
+   self
+  end
+  def self.evaluate(linq_exp)
+    Groupon.api_key = '966a0273f2974c725e25d507d4e07daabcb0ee00'
+    evaluator = GrouponExpressionEvaluator.new(linq_exp)
+    linq_exp.where.visit(evaluator)
+    selected_values = Groupon.deals(evaluator.conditions)
+    #puts evaluator.conditions.inspect
+    selected_values.collect do |e|
+      Object.send(:define_method,linq_exp.variable.to_sym) { e }
+      linq_exp.select.visit(EnumerableExpessionEvaluator.new(linq_exp))
+    end
+  end
+end
+
+
+class GrouponExpressionEvaluator < ExpressionEvaluator
+  attr_reader :conditions
+  def initialize(linq_exp)
+    @conditions = {}
+    super
+  end
+
+  def visit_binary(node)
+    right_val = node.right.visit(self)
+    left_val = node.left.visit(self)
+    @conditions[left_val] = right_val
+  end
+
+
+  def visit_call(node)
+    node.identifier.to_s.to_sym
+  end
+
+
+end

data/lib/providers/hash_provider.rb

@@ -0,0 +1,22 @@
+require 'providers/enumerable_provider'
+
+class HashProvider < EnumerableProvider
+
+  def handle_where(linq_exp)
+    filtered_values = @enumerable.lazy_select(&linq_exp.with_vars do|k,v| 
+      linq_exp.where.visit(EnumerableExpessionEvaluator.new(linq_exp))
+    end)
+  end
+
+  def handle_select(linq_exp,filtered_values)
+    filtered_values.lazy_map(&linq_exp.with_vars do |k,v|
+      linq_exp.select.visit(EnumerableExpessionEvaluator.new(linq_exp))
+    end)
+  end
+end
+
+class  Hash
+  def linqr_provider
+    HashProvider.new(self)
+  end
+end

data/lib/source_name_evaluator.rb

@@ -0,0 +1,36 @@
+require 'ripper2ruby'
+class SourceNameEvaluator
+  def source_name_arg(node)
+    node.name
+  end
+
+  def source_name_const(node)
+    node.identifier.to_s
+  end
+
+  def source_name_variable(node)
+    node.token.to_s
+  end
+end
+
+class Ruby::Arg
+  def name
+    arg.name
+  end
+end
+class Ruby::Call
+  def name
+    identifier.to_s
+  end
+end
+class Ruby::Variable
+  def name
+    to_s
+  end
+end
+
+class Ruby::Const
+  def name
+    identifier.to_s
+  end
+end

data/spec/active_record_provider_spec.rb

@@ -0,0 +1,93 @@
+require 'active_record'
+require 'linqr'
+require 'providers/active_record/activerecord_provider'
+require 'spec_helper'
+ENV['DB'] ||= "mysql"
+database_yml = File.expand_path('../database.yml', __FILE__)
+if File.exists?(database_yml)
+  active_record_configuration = YAML.load_file(database_yml)[ENV['DB']]
+  ActiveRecord::Base.establish_connection(active_record_configuration)
+  ActiveRecord::Base.silence do
+    ActiveRecord::Migration.verbose = false
+    load(File.dirname(__FILE__) + '/schema.rb')
+    load(File.dirname(__FILE__) + '/order.rb')
+end
+end
+describe "ActiveRecord Provider" do
+  before {
+    ActiveRecord::Base.connection.execute "DELETE FROM Orders"  
+  }
+
+
+  it "should select from active-record" do
+    Order.create(:name => "first")
+    Order.create(:name => "second")
+    second_order = Order.find(:all , :conditions => {:name => "second"})
+
+    output =  _{ 
+      from o
+      in_  Order
+      where o.name == "second"
+      select o
+
+    }
+    output.should == second_order
+  end
+  describe "group_by" do
+    it "should group by the attribute" do 
+      Order.create(:name => "first")
+      Order.create(:name => "second")
+      Order.create(:name => "second")
+      Order.create(:name => "third")
+
+    expected_grouped_orders = Order.find(:all , :group => :name)
+
+    grouped_by_name = _{
+        from o 
+        in_ Order
+        group_by o.name   => :g
+        select :name => g.key , :orders => g.values
+      }
+    grouped_by_name.collect(&:name).should == ["first", "second", "third"]
+    end
+  end
+  
+  describe "order by" do
+
+   it "should order by the order by operator" do
+      Order.create(:name => "berry")
+      Order.create(:name => "apple")
+      Order.create(:name => "peach")
+      Order.create(:name => "cherry")
+
+    expected_output = Order.find(:all , :order => :name).collect(&:name)
+
+    ordered_names = _{
+        from o 
+        in_ Order
+        order_by o.name
+        select o.name
+      }
+    ordered_names.should == expected_output 
+   end
+  end
+
+  describe "in" do
+    it "should retrive all object" do
+      Order.create(:name => "first")
+      Order.create(:name => "second")
+      Order.create(:name => "third")
+
+
+    first_second = Order.find(:all , :conditions => {:name => ["second", "first"]})
+
+      output =  _{ 
+        from o
+        in_ Order
+        where ["second", "first"].member?(o.name)
+        select o
+      }
+      output.should == first_second
+    end
+  end
+end

data/spec/database.yml

@@ -0,0 +1,6 @@
+mysql:
+  adapter: mysql
+  hostname: localhost
+  username: root
+  database: acts_as_aggregate_root
+  socket: /tmp/mysql.sock

data/spec/enumerable_expression_evaluator_spec.rb

@@ -0,0 +1,15 @@
+require 'linqr'
+require 'spec_helper'
+
+describe EnumerableExpessionEvaluator  do 
+
+  describe "#visit_binary" do
+    it "should invoke the operator" do 
+    x = true
+    y = false
+    p = lambda{ x && y }
+
+     #puts EnumerableExpessionEvaluator.new LinqrExp.new(p)
+    end
+  end
+end

data/spec/enumerable_provider_spec.rb

@@ -0,0 +1,101 @@
+require 'linqr'
+require 'spec_helper'
+describe "linqr" do
+  it "simple binary expression" do 
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    output =  __{ 
+      from x
+      in_ numbers
+      where x > 1
+      select x * 3
+    }
+    output.should == [15, 12, 9, 27, 24, 18, 21, 6]
+  end
+  it"a little complex binary expression"do 
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    output =  __{ 
+      from x
+      in_ numbers
+      where (x % 2) > 0
+      select x
+    }
+    output.should == [ 5, 1, 3, 9, 7 ]
+  end
+  it"compound 'or'  binary expression"do 
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    output =  __{ 
+      from x
+      in_ numbers
+      where (x == 3 ||  x == 5 || x == 8) && ( x % 2) == 0
+      select x
+    }
+    output.should == [8]
+  end
+  it"compound 'and'  binary expression"do 
+    numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+    output =  __{ 
+      from x
+      in_ numbers
+      where x > 3 && x <= 5
+      select x.to_s
+    }
+    output.should == [ '5','4']
+  end
+
+  it "query associative array" do
+    hash = {:a => 1 , :b => 2 , :c => 3}
+    output = __{
+      from k,v
+      in_ hash
+      where v == 3
+      select k
+    }
+    output.should == [:c]
+  end
+
+  it  "should work with models" do
+    Product = Struct.new(:name, :price)
+    products = [Product.new("shoes", 1.75), Product.new("glasses", 55.55), Product.new("pencil", 5.20)]
+    
+    cheap_product_names = __{
+      from p
+      in_ products 
+      where p.price < 10
+      select p.name
+    }
+
+    cheap_product_names.should == ["shoes","pencil"]
+  end
+
+  it "select into anonymous types" do
+    Product = Struct.new(:name, :price)
+    products = [Product.new("shoes", 1.75), Product.new("glasses", 55.55), Product.new("pencil", 5.20)]
+    
+    cheap_product_names = __{
+      from p
+      in_ products 
+      where p.price < 10
+      select :name => "Cheap - #{p.name}" , :new_price => p.price + 10
+    }
+    
+    cheap_product_names.collect(&:name).should == ["Cheap - shoes","Cheap - pencil"]
+    cheap_product_names.collect(&:new_price).should == [11.75, 15.20]
+
+  end
+
+  context "group by" do
+    it "simple-1" do
+      numbers = [ 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 ]
+      number_groups = __{
+        from n 
+        in_ numbers
+        where n > 3 && n < 100
+        group_by n % 5  => g
+        select :remainder => g.key , :values => g.values
+      }
+
+      number_groups.collect(&:remainder).should == [0, 4, 3, 1, 2]
+    end
+  end
+
+end

data/spec/groupon_provider_spec.rb

@@ -0,0 +1,17 @@
+require 'linqr'
+require 'spec_helper'
+require 'providers/groupon/groupon_provider'
+require 'awesome_print'
+
+describe 'Groupon provider' do 
+
+  it "should query groupon" do
+    output =  _{ 
+      from deal
+      in_  GrouponDeals
+      where deal.lat == 38.8339 && deal.lng == -104.821 
+      select deal
+    }
+    ap output.inspect
+  end
+end

data/spec/order.rb

@@ -0,0 +1,2 @@
+class Order < ActiveRecord::Base
+end

data/spec/schema.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table "orders", :force => true do |t|
+    t.column :name, :string
+    t.timestamps  
+  end
+
+
+  create_table "sub_orders", :force => true do |t|
+    t.column :order_id, :integer
+    t.column :name, :string
+    t.timestamps
+  end
+  
+  create_table "order_items", :force => true do |t|
+    t.column :sub_order_id, :integer
+    t.column :name, :string
+    t.timestamps
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+class Object
+  # alias_method :try, :__send__
+  def try(method, *args, &block)
+    send(method, *args, &block) if respond_to?(method)
+  end
+  def __(&block)
+    _(&block).to_a
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: linqr
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- surya
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-10 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+description: Linq like sytax for querying multiple-datasources
+email: surya.gaddipati@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/linqr2enumerable/ordering_operators_spec.rb
+- examples/linqr2enumerable/projection_operators_spec.rb
+- lib/expression_evaluator_base.rb
+- lib/group_by.rb
+- lib/lazy_enumerator.rb
+- lib/linqr.rb
+- lib/linqr_exp.rb
+- lib/providers/active_record/active_record_expression_evaluator.rb
+- lib/providers/active_record/activerecord_provider.rb
+- lib/providers/enumerable_expression_evaluator.rb
+- lib/providers/enumerable_provider.rb
+- lib/providers/groupon/groupon_provider.rb
+- lib/providers/hash_provider.rb
+- lib/source_name_evaluator.rb
+- spec/active_record_provider_spec.rb
+- spec/database.yml
+- spec/enumerable_expression_evaluator_spec.rb
+- spec/enumerable_provider_spec.rb
+- spec/groupon_provider_spec.rb
+- spec/order.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/suryagaddipati/linqr
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -4136635536432510828
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: Query Comprehensions for ruby
+test_files: []
+