parelation 0.0.1

data/lib/parelation/criteria/where/caster.rb

@@ -0,0 +1,82 @@
+class Parelation::Criteria::Where::Caster
+
+  # @return [String] an array of values that are considered true
+  #
+  TRUTHY_VALUES = ["1", "t", "true"]
+
+  # @return [String] an array of values that are considered false
+  #
+  FALSY_VALUES = ["0", "f", "false"]
+
+  # @return [String]
+  #
+  attr_reader :field
+
+  # @return [String]
+  #
+  attr_reader :value
+
+  # @return [Class]
+  #
+  attr_reader :klass
+
+  # @param field [Symbol] the name of the attribute that needs to be casted
+  # @param value [String] the value of the attribute that needs to be casted
+  # @param klass [Class] the corresponding field's class
+  #
+  def initialize(field, value, klass)
+    @field = field.to_s
+    @value = value
+    @klass = klass
+  end
+
+  # @return [String, Boolean, Time, nil]
+  #
+  def cast
+    case type
+    when :boolean
+      to_boolean
+    when :integer
+      to_integer
+    when :float
+      to_float
+    when :datetime
+      to_time
+    else
+      value
+    end
+  end
+
+  private
+
+  # @return [Symbol]
+  #
+  def type
+    klass.columns_hash[field].type
+  end
+
+  # @return [true, false, nil]
+  #
+  def to_boolean
+    TRUTHY_VALUES.include?(value) && (return true)
+    FALSY_VALUES.include?(value) && (return false)
+  end
+
+  # @return [Integer]
+  #
+  def to_integer
+    value.to_i
+  end
+
+  # @return [Float]
+  #
+  def to_float
+    value.to_f
+  end
+
+  # @return [Time] the parsed time string
+  #
+  def to_time
+    Time.parse(value)
+  end
+end

data/lib/parelation/criteria/where/criteria_builder.rb

@@ -0,0 +1,67 @@
+class Parelation::Criteria::Where::CriteriaBuilder
+
+  # @return [Hash]
+  #
+  attr_reader :value
+
+  # @return [ActiveRecord::Relation]
+  #
+  attr_reader :chain
+
+  # @param value [Hash] the user-provided criteria
+  # @param chain [ActiveRecord::Relation]
+  #
+  def initialize(value, chain)
+    @value = value
+    @chain = chain
+  end
+
+  # @return [Hash] criteria that can be passed into
+  #   the +where+ method of an ActiveRecord::Relation chain.
+  #
+  def build
+    value.inject(Hash.new) do |hash, (field, value)|
+      values = [value].flatten
+
+      if values.count > 1
+        assign_array(hash, field, values)
+      else
+        assign_value(hash, field, values)
+      end
+
+      hash
+    end
+  end
+
+  private
+
+  # Assigns each of the provided values to the +hash+ and casts
+  # the value to a database-readable value.
+  #
+  # @param hash [Hash]
+  # @param field [Symbol]
+  # @param values [Array]
+  #
+  def assign_array(hash, field, values)
+    values.each { |val| (hash[field] ||= []) << cast(field, val) }
+  end
+
+  # Assigns the first value of the provided values array
+  # to the +hash+ and casts it to a database-readable value.
+  #
+  # @param hash [Hash]
+  # @param field [Symbol]
+  # @param values [Array]
+  #
+  def assign_value(hash, field, values)
+    hash[field] = cast(field, values[0])
+  end
+
+  # @param field [Symbol]
+  # @param value [String]
+  #
+  def cast(field, value)
+    Parelation::Criteria::Where::Caster
+      .new(field, value, chain.arel_table.engine).cast
+  end
+end

data/lib/parelation/criteria/where/directional_query_applier.rb

@@ -0,0 +1,49 @@
+  class Parelation::Criteria::Where::DirectionalQueryApplier
+
+    # @return [Hash] keyword to operator mappings
+    #
+    OPERATOR_MAPPING = {
+      "where_gt" => ">",
+      "where_gte" => ">=",
+      "where_lt" => "<",
+      "where_lte" => "<="
+    }
+
+    # @return [String]
+    #
+    attr_reader :operator
+
+    # @return [Hash]
+    #
+    attr_reader :criteria
+
+    # @return [ActiveRecord::Relation]
+    #
+    attr_reader :chain
+
+    # @param operator [String] the named operator from the params
+    # @param criteria [Hash] the data to build query operations with
+    # @param chain [ActiveRecord::Relation] the chain to apply to
+    #
+    def initialize(operator, criteria, chain)
+      @operator = operator
+      @criteria = criteria
+      @chain = chain
+    end
+
+    # @return [ActiveRecord::Relation] the chain with newly applied operations
+    #
+    def apply
+      criteria.inject(chain) do |chain, (key, value)|
+        chain.where(sql, key, value)
+      end
+    end
+
+    private
+
+    # @return [String] the base SQL template to build queries on-top of
+    #
+    def sql
+      %Q{"#{chain.arel_table.name}".? #{OPERATOR_MAPPING[operator]} ?}
+    end
+  end

data/lib/parelation/criteria/where.rb

@@ -0,0 +1,37 @@
+class Parelation::Criteria::Where
+  include Parelation::Criteria
+
+  require_relative "where/caster"
+  require_relative "where/directional_query_applier"
+  require_relative "where/criteria_builder"
+
+  # @param param [String]
+  # @return [true, false]
+  #
+  def self.match?(param)
+    !!(param =~ /^(where|where_(not|gt|gte|lt|lte))$/)
+  end
+
+  # @return [ActiveRecord::Relation]
+  #
+  def call
+    criteria.inject(chain) do |chain, (field, value)|
+      case param
+      when "where"
+        chain.where(field => value)
+      when "where_not"
+        chain.where.not(field => value)
+      when "where_gt", "where_gte", "where_lt", "where_lte"
+        DirectionalQueryApplier.new(param, criteria, chain).apply
+      end
+    end
+  end
+
+  private
+
+  # @return [Hash] containing data used to pass to {#chain}'s +where+ method.
+  #
+  def criteria
+    @criteria ||= CriteriaBuilder.new(value, chain).build
+  end
+end

data/lib/parelation/criteria.rb

@@ -0,0 +1,24 @@
+module Parelation::Criteria
+
+  # @return [ActiveRecord::Relation] the current criteria chain
+  #
+  attr_reader :chain
+
+  # @return [String] the param param
+  #
+  attr_reader :param
+
+  # @return [String] the param value
+  #
+  attr_reader :value
+
+  # @param chain [ActiveRecord::Relation]
+  # @param param [String]
+  # @param value [String, Symbol, Array, Hash]
+  #
+  def initialize(chain, param, value)
+    @chain = chain
+    @param = param.clone
+    @value = value.clone
+  end
+end

data/lib/parelation/errors/parameter.rb

@@ -0,0 +1,2 @@
+class Parelation::Errors::Parameter < StandardError
+end

data/lib/parelation/helpers.rb

@@ -0,0 +1,12 @@
+module Parelation::Helpers
+
+  # Shorthand method used in ActionController controllers for converting
+  # and applying parameters to ActionController::Relation criteria chains.
+  #
+  # @param object [ActiveRecord::Relation]
+  # @return [ActiveRecord::Relation]
+  #
+  def parelate(object)
+    Parelation::Applier.new(object, params).apply
+  end
+end

data/lib/parelation/version.rb

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

data/lib/parelation.rb

@@ -0,0 +1,19 @@
+module Parelation
+  module Errors
+    require "parelation/errors/parameter"
+  end
+
+  module Criteria
+    require "parelation/criteria/select"
+    require "parelation/criteria/limit"
+    require "parelation/criteria/offset"
+    require "parelation/criteria/order"
+    require "parelation/criteria/query"
+    require "parelation/criteria/where"
+  end
+
+  require "parelation/applier"
+  require "parelation/criteria"
+  require "parelation/helpers"
+  require "parelation/version"
+end

data/parelation.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "parelation/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "parelation"
+  spec.version = Parelation::VERSION
+  spec.authors = ["Michael van Rooijen"]
+  spec.email = ["michael@vanrooijen.io"]
+  spec.summary = %q{Translates HTTP parameters to ActiveRecord queries.}
+  spec.homepage = "http://meskyanichi.github.io/store_schema/"
+  spec.license = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 4.1.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "yard"
+end

data/spec/lib/applier_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Parelation::Applier do
+
+  let(:klass) { Parelation::Applier }
+
+  it "should apply the requested criteria" do
+    params = {
+      "format" => :json,
+      "action" => "index",
+      "controller" => "api/v1/tickets",
+      "select" => ["id", "name", "state", "message"],
+      "where" => { state: ["open", "pending"] },
+      "where_not" => { state: "closed" },
+      "where_gt" => { created_at: "2014-01-01T00:00:00Z" },
+      "where_gte" => { updated_at: "2014-01-01T00:00:00Z" },
+      "where_lt" => { created_at: "2014-01-01T01:00:00Z" },
+      "where_lte" => { updated_at: "2014-01-01T01:00:00Z" },
+      "query" => { "ruby on rails" => ["name", "message"] },
+      "order" => ["created_at:desc", "name:asc"],
+      "limit" => "50",
+      "offset" => "100"
+    }
+
+    criteria = klass.new(Project.create.tickets, params).apply
+    ar_query = Project.create.tickets
+      .select(:id, :name, :state, :message)
+      .where(state: ["open", "pending"])
+      .where.not(state: "closed")
+      .where(%Q{"tickets".'created_at' > ?}, "2014-01-01 00:00:00.000000")
+      .where(%Q{"tickets".'updated_at' >= ?}, "2014-01-01 00:00:00.000000")
+      .where(%Q{"tickets".'created_at' < ?}, "2014-01-01 01:00:00.000000")
+      .where(%Q{"tickets".'updated_at' <= ?}, "2014-01-01 01:00:00.000000")
+      .where(
+         %Q{"tickets"."name" LIKE ? OR "tickets"."message" LIKE ?},
+         "%ruby on rails%", "%ruby on rails%"
+      )
+      .order(created_at: :desc, name: :asc)
+      .limit(50)
+      .offset(100)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "raise an exception if parameter data is invalid" do
+    params = { "order" => ["name"] }
+
+    expect { klass.new(Ticket.all, params).apply }
+      .to raise_error(Parelation::Errors::Parameter, "the order parameter is invalid")
+  end
+end

data/spec/lib/criteria/limit_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Parelation::Criteria::Limit do
+
+  let(:klass) { Parelation::Criteria::Limit }
+
+  it "should match" do
+    expect(klass.match?("limit")).to eq(true)
+  end
+
+  it "should not match" do
+    expect(klass.match?("query")).to eq(false)
+  end
+
+  it "should add criteria to the chain" do
+    criteria = klass.new(Ticket.all, "limit", "40").call
+    ar_query = Ticket.limit(40)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+end

data/spec/lib/criteria/offset_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Parelation::Criteria::Offset do
+
+  let(:klass) { Parelation::Criteria::Offset }
+
+  it "should match" do
+    expect(klass.match?("offset")).to eq(true)
+  end
+
+  it "should not match" do
+    expect(klass.match?("query")).to eq(false)
+  end
+
+  it "should add criteria to the chain" do
+    criteria = klass.new(Ticket.all, "offset", "40").call
+    ar_query = Ticket.offset(40)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+end

data/spec/lib/criteria/order_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Parelation::Criteria::Order do
+
+  let(:klass) { Parelation::Criteria::Order }
+
+  it "should match" do
+    expect(klass.match?("order")).to eq(true)
+  end
+
+  it "should not match" do
+    expect(klass.match?("query")).to eq(false)
+  end
+
+  it "should add acending order criteria to the chain" do
+    criteria = klass.new(Ticket.all, "order", "created_at:asc").call
+    ar_query = Ticket.order(created_at: :asc)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add descending order criteria to the chain" do
+    criteria = klass.new(Ticket.all, "order", "created_at:desc").call
+    ar_query = Ticket.order(created_at: :desc)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should combine multiple asc and desc order criteria" do
+    orders = %w[created_at:desc name:asc updated_at:desc message:asc]
+    criteria = klass.new(Ticket.all, "order", orders).call
+    ar_query = Ticket.order(created_at: :desc, name: :asc, updated_at: :desc, message: :asc)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+end

data/spec/lib/criteria/query_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Parelation::Criteria::Query do
+
+  let(:klass) { Parelation::Criteria::Query }
+
+  it "should match" do
+    expect(klass.match?("query")).to eq(true)
+  end
+
+  it "should not match" do
+    expect(klass.match?("not_query")).to eq(false)
+  end
+
+  it "should add single-column criteria to the chain" do
+    criteria = klass.new(Ticket.all, "query", { "ruby on rails" => "name" }).call
+    ar_query = Ticket.where(%Q{"tickets"."name" LIKE ?}, "%ruby on rails%")
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add multi-column criteria to the chain" do
+    criteria = klass.new(Ticket.all, "query", { "ruby on rails" => ["name", "message"] }).call
+    ar_query = Ticket.where(
+      %Q{"tickets"."name" LIKE ? OR "tickets"."message" LIKE ?},
+      "%ruby on rails%", "%ruby on rails%"
+    )
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+end

data/spec/lib/criteria/select_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Parelation::Criteria::Select do
+
+  let(:klass) { Parelation::Criteria::Select }
+
+  it "should match" do
+    expect(klass.match?("select")).to eq(true)
+  end
+
+  it "should not match" do
+    expect(klass.match?("query")).to eq(false)
+  end
+
+  it "should add criteria to the chain" do
+    criteria = klass.new(Ticket.all, "select", ["id", "name"]).call
+    ar_query = Ticket.all.select(:id, :name)
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+end

data/spec/lib/criteria/where_spec.rb

@@ -0,0 +1,157 @@
+require "spec_helper"
+
+describe Parelation::Criteria::Where do
+
+  let(:klass) { Parelation::Criteria::Where }
+
+  it "should match" do
+    operators = %w[where where_not where_gt where_gte where_lt where_lte]
+    operators.each { |operator| expect(klass.match?(operator)).to eq(true) }
+  end
+
+  it "should not match" do
+    expect(klass.match?("query")).to eq(false)
+  end
+
+  it "should add = criteria to the chain when argument is a value" do
+    criteria = klass.new(Ticket.all, "where", state: "open").call
+    ar_query = Ticket.where(state: "open")
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add = criteria to the chain when argument is an array" do
+    criteria = klass.new(Ticket.all, "where", state: ["open"]).call
+    ar_query = Ticket.where(state: "open")
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add IN criteria to the chain when values are many" do
+    criteria = klass.new(Ticket.all, "where", state: ["open", "pending"]).call
+    ar_query = Ticket.where(state: ["open", "pending"])
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add != criteria to the chain when argument is a value" do
+    criteria = klass.new(Ticket.all, "where_not", state: "open").call
+    ar_query = Ticket.where.not(state: "open")
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add != criteria to the chain when argument is an array" do
+    criteria = klass.new(Ticket.all, "where_not", state: "open").call
+    ar_query = Ticket.where.not(state: "open")
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  it "should add NOT IN criteria to the chain when values are many" do
+    criteria = klass.new(Ticket.all, "where_not", state: ["open", "pending"]).call
+    ar_query = Ticket.where.not(state: ["open", "pending"])
+
+    expect(criteria.to_sql).to eq(ar_query.to_sql)
+  end
+
+  [%w[where_gt >], %w[where_gte >=], %w[where_lt <], %w[where_lte <=]]
+    .each do |(operator, symbol)|
+
+    it "should add #{symbol} criteria to the chain" do
+      criteria = klass.new(Ticket.all, operator, created_at: "2014-08-26T19:20:44Z").call
+      ar_query = Ticket.where(
+        %Q{"tickets".'created_at' #{symbol} ?}, "2014-08-26 19:20:44.000000"
+      )
+
+      expect(criteria.to_sql).to eq(ar_query.to_sql)
+    end
+
+    it "should add multiple #{symbol} criteria to the chain" do
+      criteria = klass.new(Ticket.all, operator, created_at: "2014-08-26T19:20:44Z", position: "5").call
+      ar_query = Ticket.where(%Q{"tickets".'created_at' #{symbol} ?}, "2014-08-26 19:20:44.000000")
+                       .where(%Q{"tickets".'position' #{symbol} ?}, 5)
+
+      expect(criteria.to_sql).to eq(ar_query.to_sql)
+    end
+  end
+
+  describe "relations" do
+
+    before do
+      @project1 = Project.create
+      @project2 = Project.create
+      @ticket1 = @project1.tickets.create
+      @ticket2 = @project2.tickets.create
+    end
+
+    it "should yield related resources" do
+      tickets = @project1.tickets
+      expect(tickets.count).to eq(1)
+      expect(tickets.first).to eq(@ticket1)
+    end
+
+    it "should yield results when using the same foreign key" do
+      chain = klass.new(@project1.tickets, "where", project_id: @project1.id).call
+      expect(chain.count).to eq(1)
+      expect(chain.first).to eq(@ticket1)
+    end
+
+    it "should not override foreign key, nor yield results" do
+      chain = klass.new(@project1.tickets, "where", project_id: @project2.id).call
+      expect(chain.count).to eq(0)
+      expect(chain.to_sql).to eq(@project1.tickets.where(project_id: @project2.id).to_sql)
+    end
+  end
+
+  describe "casting:boolean" do
+
+    ["1", "t", "true"].each do |string_bool|
+      it "should cast #{string_bool} to true" do
+        criteria = klass.new(Ticket.all, "where", resolved: string_bool).call
+        ar_query = Ticket.where(resolved: true)
+
+        expect(criteria.to_sql).to eq(ar_query.to_sql)
+      end
+    end
+
+    ["0", "f", "false"].each do |string_bool|
+      it "should cast #{string_bool} to false" do
+        criteria = klass.new(Ticket.all, "where", resolved: string_bool).call
+          ar_query = Ticket.where(resolved: false)
+
+          expect(criteria.to_sql).to eq(ar_query.to_sql)
+      end
+    end
+  end
+
+  describe "casting:integer" do
+
+    it "should cast a string to integer" do
+      criteria = klass.new(Ticket.all, "where", position: "5").call
+      ar_query = Ticket.where(position: 5)
+
+      expect(criteria.to_sql).to eq(ar_query.to_sql)
+    end
+  end
+
+  describe "casting:float" do
+
+    it "should cast a string to float" do
+      criteria = klass.new(Ticket.all, "where", rating: "2.14").call
+      ar_query = Ticket.where(rating: 2.14)
+
+      expect(criteria.to_sql).to eq(ar_query.to_sql)
+    end
+  end
+
+  describe "casting:datetime" do
+
+    it "should cast a string to time" do
+      criteria = klass.new(Ticket.all, "where", created_at: "2014-01-01T00:00:00Z").call
+      ar_query = Ticket.where(created_at: '2014-01-01 00:00:00.000000')
+
+      expect(criteria.to_sql).to eq(ar_query.to_sql)
+    end
+  end
+end