httpsql 0.1.2 → 0.2.0

data/.coveralls.yml

@@ -0,0 +1 @@
+repo_token: mUabjcN9fjNpphNtEUHYDJtE1VzEa8p12

data/.gitignore

@@ -15,3 +15,6 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+*.sw[a-z]
+*~
+*.orig

data/README.md

@@ -1,26 +1,31 @@
 # Httpsql
 
 [![Gem Version](https://badge.fury.io/rb/httpsql.png)](http://badge.fury.io/rb/httpsql)
-[![Build Status](https://travis-ci.org/Adaptly/httpsql.png)](https://travis-ci.org/Adaptly/httpsql)
+[![Build Status](https://travis-ci.org/Adaptly/httpsql.png?branch=master)](https://travis-ci.org/Adaptly/httpsql)
 [![Code Climate](https://codeclimate.com/github/Adaptly/httpsql.png)](https://codeclimate.com/github/Adaptly/httpsql)
 [![Dependency Status](https://gemnasium.com/Adaptly/httpsql.png)](https://gemnasium.com/Adaptly/httpsql)
 [![Coverage Status](https://coveralls.io/repos/Adaptly/httpsql/badge.png)](https://coveralls.io/r/Adaptly/httpsql)
 
-Httpsql is a module, designed to be included in [Active Record](http://api.rubyonrails.org/classes/ActiveRecord/Base.html) 
-models exposed by [grape](https://github.com/intridea/grape). Once the module is
-included, a given model can respond directly to query params passed to it, using
-`where_params_eq`. You can also constrain the fields returned by the model,
-using the `fields` query parameter.
+Httpsql is a module, designed to be included in [Active
+Record](http://api.rubyonrails.org/classes/ActiveRecord/Base.html) models
+exposed by [grape](https://github.com/intridea/grape). Once the module is
+included, a given model can respond directly to query params passed to it,
+using `with_params`. You can constrain the fields returned by the model, using
+the `field` query parameter. You can also use httpsql to group, join, and order
+results. Currently, only inner joins are supported, using rudimentary Active
+Record joins.
 
 Httpsql uses [ARel](http://www.slideshare.net/flah00/activerecord-arel) to
 generate queries and exposes ARel's methods via query params. The supported ARel 
-methods are eq, not_eq, matches, does_not_match, gt, gteq, lt, lteq.
+methods are eq, not_eq, matches, does_not_match, gt, gteq, lt, lteq, sum, 
+maximum, and minimum. It is also possible to pass columns to arbitrary SQL 
+functions. 
 
 Httpsql also generates documentaion for endpoints, which can be easily merged
-into your existing documentation (`#route_params`).
+into your existing documentation (`#grape_documentation`).
 
-Httpsql reserves one parameter, access_token. If your model has a field called
-access_token, you'll need to rename it.
+Httpsql reserves the following parameters access_token, field, group, join, and order. If
+your model has any columns by the same name, you'll need to rename them.
 
 ## Installation
 
@@ -48,13 +53,29 @@ Assume you have a model, widget, whose fields are id, int_field, string_field, c
       t.datetime "updated_at", :null => false
     end
 
-### model.rb
+    create_table "dongles", :force => true do |t|
+      t.integer  "widget_id"
+      t.string   "description"
+      t.datetime "created_at", :null => false
+      t.datetime "updated_at", :null => false
+    end
+
+### widget.rb
 
     class Widget < ActiveRecord::Base
       include Httpsql
+      has_many :dongles
       attr_accessible :int_field, :dec_field, :string_field
     end
 
+### dongle.rb
+
+    class Dongle < ActiveRecord::Base
+      include Httpsql
+      belongs_to :widget
+      attr_accessible :description
+    end
+
 ### api.rb
 
     class Api < Grape::API
@@ -63,13 +84,25 @@ Assume you have a model, widget, whose fields are id, int_field, string_field, c
       default_format :json
 
       resource :widgets do
-        desc 'Get all widgets', {
-          optional_params: Widget.route_params
-        }
+        desc 'Get all widgets'
+        params do
+          Widget.grape_documentation(self)
+        end
         get '/' do
-          present Widget.where_params_eq(params)
+          Widget.with_params(params)
         end
       end
+
+      resource :dongles do
+        desc 'Get all dongles'
+        params do
+          Dongle.grape_documentation(self)
+        end
+        get '/' do
+          Dongle.with_params(params)
+        end
+      end
+
     end
 
 ### config.ru
@@ -102,9 +135,18 @@ Query your new API
     curl 'http://localhost:3000/api/v1/widgets?id[]=1&id[]=2&created_at.gt=2013-06-01'
     SELECT * FROM widgets WHERE id IN (1,2) AND created_at > '2013-06-01'
 
-    curl 'http://localhost:3000/api/v1/widgets?id[]=1&id[]=2&created_at.gt=2013-06-01&fields[]=id&fields[]=int_field'
+    curl 'http://localhost:3000/api/v1/widgets?id[]=1&id[]=2&created_at.gt=2013-06-01&field[]=id&field[]=int_field'
     SELECT id, int_field FROM widgets WHERE id IN (1,2) AND created_at > '2013-06-01'
 
+    curl 'http://localhost:3000/api/v1/widgets?order=widgets.int_field+desc'
+    SELECT * FROM widgets ORDER BY widgets.int_field desc
+
+    curl 'http://localhost:3000/api/v1/widgets?group=widgets.int_field'
+    SELECT * FROM widgets GROUP BY widgets.int_field
+
+    curl 'http://localhost:3000/api/v1/dongles?field[]=description&field[]=widgets.int_field&join[]=widgets&group[]=widgets.string_field&order=string_field'
+    SELECT dongles.description, widgets.int_field FROM dongles INNER JOIN widgets ON (widgets.id = dongles.widget_id) GROUP BY widgets.string_field ORDER BY dongles.string_field
+
     curl 'http://localhost:3000/api/v1/widgets?int_field.sum'
     SELECT SUM(int_field) AS int_field FROM widgets
 

data/gemfiles/activerecord_3.1.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 gem "activerecord", "~> 3.1.0"
-gem "grape"
+gem "grape", ">= 0.5.0"
 gem "bundler", "~> 1.3"
 gem "coveralls", ">= 0.5.7"
 gem "rake"

data/gemfiles/activerecord_3.2.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 gem "activerecord", "~> 3.2.0"
-gem "grape"
+gem "grape", ">= 0.5.0"
 gem "bundler", "~> 1.3"
 gem "coveralls", ">= 0.5.7"
 gem "rake"

data/gemfiles/activerecord_4.0.gemfile

@@ -1,6 +1,7 @@
 source "https://rubygems.org"
+gem "minitest", "~> 4.2"
 gem "activerecord", "~> 4.0.0"
-gem "grape"
+gem "grape", ">= 0.5.0"
 gem "bundler", "~> 1.3"
 gem "coveralls", ">= 0.5.7"
 gem "rake"

data/httpsql.gemspec

@@ -18,11 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", ">= 3.1"
+  spec.add_dependency "activerecord", "~> 3.2"
   spec.add_dependency "arel", ">= 2.2"
-  spec.add_dependency "grape"
+  spec.add_dependency "grape", ">= 0.5.0"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "coveralls", ">= 0.5.7"
+  spec.add_development_dependency "minitest", "~> 4.2"
+  spec.add_development_dependency "pry-nav"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "simplecov", ">= 0.7"
   spec.add_development_dependency "sqlite3"

data/lib/httpsql.rb

@@ -6,14 +6,35 @@ module Httpsql
   end
 
   module ClassMethods
-    def where_params_eq(params={})
-      fields = params[:field] || []
-      conds = []
+    # The method to call within API end points
+    # @param params [Hash] The params hash for a given API request
+    # @return [ActiveRecord::Relation]
+    # @example Constraining a model index end point
+    #   resource :my_models
+    #     get '/' do
+    #       MyModel.with_params(params)
+    #     end
+    #   end
+    def with_params(params={})
+      fields = []
+      conds  = []
+      joins  = []
+      groups = []
+      orders = []
 
-      valid_params(params).each do |k,v|
-        (k, m) = k.to_s.split('.')
+      fields += Array(params[:field] || params['field'])
+
+      httpsql_valid_params(params).each do |k,v|
+        k, m = k.to_s.split('.')
         next if k.to_s == 'access_token' 
-        if m
+
+        if k == 'join'
+          joins += Array(v).map!(&:to_sym)
+        elsif k == 'order'
+          orders += Array(v).map!{|w| httpsql_quote_value_with_args(w)}
+        elsif k == 'group'
+          groups += Array(v).map!{|w| httpsql_quote_value(w)}
+        elsif m
           if %w(sum minimum maximum).include?(m)
             fields << arel_table[k].send(m).as(k)
           elsif !arel_table[k].respond_to?(m)
@@ -32,29 +53,71 @@ module Httpsql
       conds = conds.compact.inject{|x,y| x.and(y)}
 
       ar_rel = where(conds)
+      ar_rel = ar_rel.joins(joins)   if joins.any?
+      ar_rel = ar_rel.group(groups)  if groups.any?
+      ar_rel = ar_rel.order(orders)  if orders.any?
       ar_rel = ar_rel.select(fields) if fields.any?
       ar_rel
     end
 
-    def route_params
-      columns.inject({}) do |m,c| 
-        m[c.name] = {
-          type: c.sql_type,
-          desc: c.name,
-          primary: c.primary
-        }
-        m
-      end.merge "field" => {
-        type: 'array',
-        desc: 'select fields',
-        primary: false
-      }
+    # Provide documentation for Grape end points
+    # @param ctx [Object] The calling object
+    # @return [Hash]
+    # @example Including documentation
+    #   params do
+    #     MyModel.grape_documentation(self)
+    #   end
+    def grape_documentation(ctx=nil)
+      columns.each do |c|
+        opt_hash = {}
+        if (k = httpsql_sql_type_conversion(c.type))
+          opt_hash[:type] = k 
+        end
+        ctx.optional c.name, opt_hash
+      end
+      ctx.optional :field, type: Array, desc: "An array of strings: fields to select from the database"
+      ctx.optional :group, type: Array, desc: "An array of strings: fields to group by"
+      ctx.optional :order, type: Array, desc: "An array of strings: fields to order by"
+      ctx.optional :join,  type: Array, desc: "An array of strings: tables to join (#{httpsql_join_tables.join(',')})"
     end
 
     private
-    def valid_params(params)
-      params.select{|k,v| column_names.include?(k.to_s.split('.').first)}
+    def httpsql_valid_params(params)
+      params.select{|k,v| [*column_names, 'join', 'group', 'order'].include?(k.to_s.split('.').first)}
     end
+
+    def httpsql_quote_value(v)
+      v['.'].nil? ? arel_table[v] : v.split('.').map!{|x| connection.quote_table_name(x)}.join('.')
+    end
+
+    def httpsql_quote_value_with_args(v)
+      match = v.match(/([^\s]+)(?:\s+(.*))?/)
+      q = httpsql_quote_value(match[1])
+      if match[2]
+        if q.kind_of?(String)
+          q + " " + match[2]
+        else
+          q.send(match[2])
+        end
+      end
+    end
+
+    def httpsql_sql_type_conversion(type)
+      case type.to_sym
+        when :bigint then Bignum
+        when :date then Date
+        when :datetime then Time
+        when :float, :decimal then Float
+        when :integer then Fixnum
+        when :string, /text/, /^char/, /^varchar/ then String
+        else nil
+      end
+    end
+
+    def httpsql_join_tables
+      @join_tables ||= reflections.keys
+    end
+
   end
 end
 

data/lib/httpsql/version.rb

@@ -1,3 +1,3 @@
 module Httpsql
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/test/httpsql_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-def generate_models
+def generate_foo_models
   FooModel.create!([
     {int_field: 0, dec_field: 0.01, string_field: "zero",  access_token: "000"},
     {int_field: 1, dec_field: 1.01, string_field: "one",   access_token: "111"},
@@ -10,120 +10,269 @@ def generate_models
   ])
 end
 
+def generate_bar_models
+  BarModel.create!([
+    {foo_model_id: 1, string_field: "zero"},
+    {foo_model_id: 2, string_field: "one"},
+  ])
+end
+
+def generate_baz_models
+  BazModel.create!([
+    {foo_model_id: 1, string_field: "zeropointzero"},
+    {foo_model_id: 1, string_field: "zeropointone"},
+    {foo_model_id: 2, string_field: "onepointzero"},
+    {foo_model_id: 2, string_field: "onepointone"},
+  ])
+end
+
 describe Httpsql do
   before :each do
     FooModel.connection.execute %Q{DELETE FROM foo_models}
+    FooModel.connection.execute %Q{DELETE FROM bar_models}
+    FooModel.connection.execute %Q{DELETE FROM baz_models}
   end
 
-  it 'selects a model\'s columns from a given hash' do
-    ret = FooModel.send(:valid_params, id: 1, int_field: 2, string_field: "foo", access_token: "a", created_at: '2013-01-01T00:00:00', created_at: '2013-01-01T00:00:00', foo: :bar)
-    ret.must_equal(id: 1, int_field: 2, string_field: "foo", access_token: "a", created_at: '2013-01-01T00:00:00', created_at: '2013-01-01T00:00:00')
-  end
+  describe "#httpsql_valid_params" do
+    it 'selects a model\'s columns from a given hash' do
+      ret = FooModel.send(:httpsql_valid_params, id: 1, int_field: 2, string_field: "foo", access_token: "a", created_at: '2013-01-01T00:00:00', created_at: '2013-01-01T00:00:00', foo: :bar)
+      ret.must_equal(id: 1, int_field: 2, string_field: "foo", access_token: "a", created_at: '2013-01-01T00:00:00', created_at: '2013-01-01T00:00:00')
+    end
 
-  it 'selects all models' do
-    models = generate_models
-    FooModel.where_params_eq({}).must_equal models
+    it 'selects reserved parameters' do
+      ret = FooModel.send(:httpsql_valid_params, 'join'=>'foo', 'group'=>'bar', 'order'=>'baz')
+      ret.must_equal('join'=>'foo', 'group'=>'bar', 'order'=>'baz')
+    end
   end
 
-  it 'selects a specified array of models' do
-    models = generate_models
-    FooModel.where_params_eq("int_field" => [0, 1]).must_equal models[0..1]
-  end
+  describe '#with_params' do
+    it 'selects all models' do
+      models = generate_foo_models
+      FooModel.with_params({}).must_equal models
+    end
 
-  it 'selects a model, using eq' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.eq" => 0).must_equal [models[0]]
-  end
+    it 'selects a specified array of models' do
+      models = generate_foo_models
+      FooModel.with_params("int_field" => [0, 1]).must_equal models[0..1]
+    end
 
-  it 'selects models, using not_eq' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.not_eq" => 0).must_equal models[1..-1]
-  end
+    it 'selects a model, using eq' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.eq" => 0).must_equal [models[0]]
+    end
 
-  it 'selects a model, using matches' do
-    models = generate_models
-    FooModel.where_params_eq("string_field.matches" => "%hre%").must_equal [models[3]]
-  end
+    it 'selects models, using not_eq' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.not_eq" => 0).must_equal models[1..-1]
+    end
 
-  it 'selects models, using does_not_match' do
-    models = generate_models
-    FooModel.where_params_eq("string_field.does_not_match" => "%ero").must_equal models[1..-1]
-  end
-  it 'selects models, using gt' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.gt" => 1).must_equal models[2..-1]
-  end
+    it 'selects a model, using matches' do
+      models = generate_foo_models
+      FooModel.with_params("string_field.matches" => "%hre%").must_equal [models[3]]
+    end
 
-  it 'selects models, using gteq' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.gteq" => 2).must_equal models[2..-1]
-  end
+    it 'selects models, using does_not_match' do
+      models = generate_foo_models
+      FooModel.with_params("string_field.does_not_match" => "%ero").must_equal models[1..-1]
+    end
+    it 'selects models, using gt' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.gt" => 1).must_equal models[2..-1]
+    end
 
-  it 'select models, using lt' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.lt" => 1).must_equal [models[0]]
-  end
+    it 'selects models, using gteq' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.gteq" => 2).must_equal models[2..-1]
+    end
 
-  it 'selects models, using lteq' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.lteq" => 2).must_equal models[0..2]
-  end
+    it 'select models, using lt' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.lt" => 1).must_equal [models[0]]
+    end
 
-  it 'selects models, using two ARel methods' do
-    models = generate_models
-    FooModel.where_params_eq("int_field.gteq" => 1, "id.gt" => 4).must_equal [models[4]]
-  end
+    it 'selects models, using lteq' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.lteq" => 2).must_equal models[0..2]
+    end
 
-  it 'ignores access_token' do
-    models = generate_models
-    FooModel.where_params_eq("access_token" => "111").must_equal models
-  end
+    it 'selects models, using two ARel methods' do
+      models = generate_foo_models
+      FooModel.with_params("int_field.gteq" => 1, "id.gt" => 4).must_equal [models[4]]
+    end
 
-  it 'ignores access_token dot notation' do
-    models = generate_models
-    FooModel.where_params_eq("access_token.eq" => "111").must_equal models
-  end
+    it 'ignores access_token' do
+      models = generate_foo_models
+      FooModel.with_params("access_token" => "111").must_equal models
+    end
 
-  it 'selects a model with specified fields' do
-    generate_models
-    model = FooModel.select([:int_field, :id]).where(int_field: 0)
-    FooModel.where_params_eq("int_field.eq" => 0, field: [:int_field, :id]).must_equal model
-  end
+    it 'ignores access_token dot notation' do
+      models = generate_foo_models
+      FooModel.with_params("access_token.eq" => "111").must_equal models
+    end
+
+    it 'selects a model with specified fields' do
+      generate_foo_models
+      model = FooModel.select([:int_field, :id]).where(int_field: 0)
+      FooModel.with_params("int_field.eq" => 0, field: [:int_field, :id]).must_equal model
+    end
+
+    it 'sums the specified field' do
+      models = generate_foo_models
+      expected = models.collect(&:int_field).inject(:+)
+      FooModel.with_params("int_field.sum" => nil).first.int_field.must_equal expected
+    end
+
+    it 'selects the maximum value for the specified field' do
+      models = generate_foo_models
+      expected = models.collect(&:int_field).max
+      FooModel.with_params("int_field.maximum" => nil).first.int_field.must_equal expected
+    end
+
+    it 'selects the minimum value for the specified field' do
+      models = generate_foo_models
+      expected = models.collect(&:int_field).min
+      FooModel.with_params("int_field.minimum" => nil).first.int_field.must_equal expected
+    end
+
+    it 'generates the specified sql for rounding' do
+      models = generate_foo_models
+      expected = models.collect(&:dec_field).map{|v| v.round.to_f}
+      FooModel.with_params("dec_field.round" => "1").collect(&:dec_field).map{|v| v.to_f}.must_equal expected
+    end
+
+    it 'groups correctly' do
+      models = generate_foo_models
+      expected = [FooModel.create({created_at: "1900-01-01"}), models.last]
+      FooModel.with_params("group" => "created_at").must_equal expected
+    end
+
+    it 'orders unqualified fields correctly' do
+      models = generate_foo_models
+      expected = models.reverse
+      FooModel.with_params("order" => "int_field desc").must_equal expected
+    end
+
+    it 'orders qualified fields correctly' do
+      models = generate_foo_models
+      expected = models.reverse
+      FooModel.with_params("order" => "foo_models.int_field desc").must_equal expected
+    end
+
+    it 'joins has_one relations' do
+      models = generate_foo_models
+      generate_bar_models
+      FooModel.with_params("join" => "bar_model").to_a.must_equal models[0..1]
+    end
+
+    it 'joins has_many relations' do
+      models = generate_foo_models
+      generate_baz_models
+      FooModel.with_params("join" => "baz_models").to_a.must_equal [models[0], models[0], models[1], models[1]]
+    end
+
+    it 'joins has_many relations and uses field and group' do
+      models = generate_foo_models
+      generate_baz_models
+      expected = [
+        {"int_field"=>1, "string_field"=>"onepointone"},
+        {"int_field"=>1, "string_field"=>"onepointzero"},
+        {"int_field"=>0, "string_field"=>"zeropointone"},
+        {"int_field"=>0, "string_field"=>"zeropointzero"},
+      ]
+      ## TODO: sqlite3 && activerecord-4.0 insert an id field... why!?
+      expected.map! do |e|
+        e["id"] = nil
+        e
+      end if ActiveRecord::VERSION::MAJOR >= 4
+      query = BazModel.with_params("join" => "foo_model", 
+                                   "field" => ["foo_models.int_field", "baz_models.string_field"], 
+                                   "group" => ["baz_models.string_field"],
+                                   "order" => ["baz_models.string_field"])
+      query.collect(&:attributes).must_equal expected
+    end
 
-  it 'sums the specified field' do
-    models = generate_models
-    expected = models.collect(&:int_field).inject(:+)
-    FooModel.where_params_eq("int_field.sum" => nil).first.int_field.must_equal expected
   end
 
-  it 'selects the maximum value for the specified field' do
-    models = generate_models
-    expected = models.collect(&:int_field).max
-    FooModel.where_params_eq("int_field.maximum" => nil).first.int_field.must_equal expected
+  describe "#httpsql_quote_value" do
+    it "quotes absolute names" do
+      FooModel.send(:httpsql_quote_value, "foo.bar").must_equal "\"foo\".\"bar\""
+    end
+
+    it "converts column names to arel nodes" do
+      FooModel.send(:httpsql_quote_value, "int_field").must_be_kind_of Arel::Attributes::Attribute
+    end
   end
 
-  it 'selects the minimum value for the specified field' do
-    models = generate_models
-    expected = models.collect(&:int_field).min
-    FooModel.where_params_eq("int_field.minimum" => nil).first.int_field.must_equal expected
+  describe "#httpsql_quote_value_with_args" do
+    it "quotes absolute names" do
+      FooModel.send(:httpsql_quote_value, "foo.bar").must_equal "\"foo\".\"bar\""
+    end
+
+    it "quotes absolute names with args" do
+      FooModel.send(:httpsql_quote_value_with_args, "foo.bar baz").must_equal "\"foo\".\"bar\" baz"
+    end
   end
 
-  it 'generates the specified sql for rounding' do
-    models = generate_models
-    expected = models.collect(&:dec_field).map{|v| v.round.to_f}
-    FooModel.where_params_eq("dec_field.round" => "1").collect(&:dec_field).map{|v| v.to_f}.must_equal expected
+  describe '#httpsql_sql_type_conversion' do
+    it 'identifies bigint as Bignum' do
+      FooModel.send(:httpsql_sql_type_conversion, 'bigint').must_equal Bignum
+    end
+
+    it 'identifies date as Date' do
+      FooModel.send(:httpsql_sql_type_conversion, 'date').must_equal Date
+    end
+
+    it 'identifies datetime as Time' do
+      FooModel.send(:httpsql_sql_type_conversion, 'datetime').must_equal Time
+    end
+
+    it 'identifies float as Float' do
+      FooModel.send(:httpsql_sql_type_conversion, 'float').must_equal Float
+    end
+
+    it 'identifies decimal as Bignum' do
+      FooModel.send(:httpsql_sql_type_conversion, 'decimal').must_equal Float
+    end
+
+    it 'identifies integer as Fixnum' do
+      FooModel.send(:httpsql_sql_type_conversion, 'integer').must_equal Fixnum
+    end
+
+    it 'identifies string as String' do
+      FooModel.send(:httpsql_sql_type_conversion, 'string').must_equal String
+    end
+
+    it 'identifies text as String' do
+      FooModel.send(:httpsql_sql_type_conversion, 'text').must_equal String
+    end
+
+    it 'identifies character varying(255) as String' do
+      FooModel.send(:httpsql_sql_type_conversion, 'character varying(255)').must_equal String
+    end
+
+    it 'identifies something as nil' do
+      FooModel.send(:httpsql_sql_type_conversion, 'something').must_be_nil
+    end
   end
 
-  it 'generates the correct documentation' do
-    FooModel.route_params.must_equal({
-      "id"           => {:type => "integer", :desc => "id",            :primary => true},
-      "int_field"    => {:type => "integer", :desc => "int_field",     :primary => false},
-      "dec_field"    => {:type => "decimal", :desc => "dec_field",     :primary => false},
-      "string_field" => {:type => "text",    :desc => "string_field",  :primary => false},
-      "access_token" => {:type => "text",    :desc => "access_token",  :primary => false},
-      "created_at"   => {:type => "text",    :desc => "created_at",    :primary => false},
-      "updated_at"   => {:type => "text",    :desc => "updated_at",    :primary => false},
-      "field"        => {:type => "array",   :desc => "select fields", :primary => false}}
-    )
+  describe '#grape_documentation' do
+    it 'generates the correct documentation for version 0.5.x' do
+      TestApi.routes.first.route_params.must_equal({
+        "id"           => {:required => false, :type => "Fixnum"},
+        "int_field"    => {:required => false, :type => "Fixnum"},
+        "dec_field"    => {:required => false, :type => "Float"},
+        "string_field" => {:required => false, :type => "String"},
+        "access_token" => {:required => false, :type => "String"},
+        "created_at"   => {:required => false, :type => "String"},
+        "updated_at"   => {:required => false, :type => "String"},
+        "field"        => {:required => false, :type => "Array",   :desc => "An array of strings: fields to select from the database"},
+        "group"        => {:required => false, :type => "Array",   :desc => "An array of strings: fields to group by"},
+        "order"        => {:required => false, :type => "Array",   :desc => "An array of strings: fields to order by"},
+        "join"         => {:required => false, :type => "Array",   :desc => "An array of strings: tables to join (bar_model,baz_models)"}
+
+      })
+    end
+
   end
+
 end

data/test/test_helper.rb

@@ -1,12 +1,14 @@
+require 'simplecov'
+#SimpleCov.start
+require 'coveralls'
+Coveralls.wear!
+
 require 'minitest/spec'
 require 'minitest/autorun'
 require 'active_record'
+require 'grape'
 require 'httpsql'
 
-require 'simplecov'
-require 'coveralls'
-Coveralls.wear!
-
 ActiveRecord::Base.configurations[:test] = {adapter:  'sqlite3', database: 'tmp/httpsql_test'}
 ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[:test])
 ActiveRecord::Base.connection.execute %Q{ DROP TABLE IF EXISTS foo_models }
@@ -22,8 +24,79 @@ ActiveRecord::Base.connection.execute %Q{
     primary key(id)
   );
 }
+
+ActiveRecord::Base.connection.execute %Q{ DROP TABLE IF EXISTS bar_models }
+ActiveRecord::Base.connection.execute %Q{ 
+  CREATE TABLE bar_models (
+    id integer,
+    foo_model_id integer,
+    string_field text,
+    primary key(id)
+  );
+}
+
+ActiveRecord::Base.connection.execute %Q{ DROP TABLE IF EXISTS baz_models }
+ActiveRecord::Base.connection.execute %Q{ 
+  CREATE TABLE baz_models (
+    id integer,
+    foo_model_id integer,
+    string_field text,
+    primary key(id)
+  );
+}
+
+ActiveRecord::Base.connection.execute %Q{ DROP TABLE IF EXISTS bam_models }
+ActiveRecord::Base.connection.execute %Q{ 
+  CREATE TABLE bam_models (
+    id integer,
+    bar_model_id integer,
+    string_field text,
+    primary key(id)
+  );
+}
+
 class FooModel < ActiveRecord::Base
   include Httpsql
-  #attr_accessible :int_field, :dec_field, :string_field, :access_token
+  has_one :bar_model
+  has_many :baz_models
+end
+
+class BarModel < ActiveRecord::Base
+  include Httpsql
+  belongs_to :foo_model
+  has_many :bam_models
+end
+
+class BazModel < ActiveRecord::Base
+  include Httpsql
+  belongs_to :foo_model
+end
+
+class BamModel < ActiveRecord::Base
+  include Httpsql
+  belongs_to :bar_model
+end
+
+class TestApi < Grape::API
+  resource :foo_models do
+    desc 'foo models index'
+    params do
+      FooModel.grape_documentation(self)
+    end
+    get '/' do
+      FooModel.with_params(params)
+    end
+  end
+
+  resource :baz_models do
+    desc 'baz models index'
+    params do
+      BazModel.grape_documentation(self)
+    end
+    get '/' do
+      BazModel.with_params(params)
+    end
+  end
+
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: httpsql
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,24 +11,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: arel
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +52,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -60,7 +60,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +93,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.5.7
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -151,6 +183,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .coveralls.yml
 - .gitignore
 - .travis.yml
 - Gemfile