fastapi 0.1.27 → 0.2.0

data/lib/fastapi/comparison.rb

@@ -0,0 +1,91 @@
+module FastAPI
+  class Comparison
+
+    attr_reader :sql
+    alias_method :to_s, :sql
+
+    @@scalar_input = {
+      is:  '__FIELD__ = __VALUE__',
+      not: '__FIELD__ <> __VALUE__',
+      gt:  '__FIELD__ > __VALUE__',
+      gte: '__FIELD__ >= __VALUE__',
+      lt:  '__FIELD__ < __VALUE__',
+      lte: '__FIELD__ <= __VALUE__',
+      like:   '__FIELD__ LIKE \'%\' || __VALUE__ || \'%\'',
+      ilike:  '__FIELD__ ILIKE \'%\' || __VALUE__ || \'%\'',
+      not_like:   'NOT (__FIELD__ LIKE \'%\' || __VALUE__ || \'%\')',
+      not_ilike:  'NOT (__FIELD__ ILIKE \'%\' || __VALUE__ || \'%\')',
+      null:    '__FIELD__ IS NULL',
+      not_null:   '__FIELD__ IS NOT NULL'
+    }.with_indifferent_access
+
+    @@multi_input = {
+      in: '__FIELD__ IN (__VALUES__)',
+      not_in: '__FIELD__ NOT IN (__VALUES__)',
+      subset: '__FIELD__ <@ ARRAY[__VALUES__]::__TYPE__[]',
+      not_subset: 'NOT __FIELD__ <@ ARRAY[__VALUES__]::__TYPE__[]',
+      contains: '__FIELD__ @> ARRAY[__VALUES__]::__TYPE__[]',
+      not_contains: 'NOT __FIELD__ @> ARRAY[__VALUES__]::__TYPE__[]',
+      intersects:     '__FIELD__ && ARRAY[__VALUES__]::__TYPE__[]',
+      not_intersects: 'NOT __FIELD__ && ARRAY[__VALUES__]::__TYPE__[]'
+    }.with_indifferent_access
+
+    @@booleans = {
+      t: true,
+      true: true,
+      f: false,
+      false: false
+    }.with_indifferent_access
+
+    @@types = Hash.new('text').merge({
+      boolean: 'boolean',
+      integer: 'integer',
+      float:   'float',
+      string:  'varchar'
+    }).with_indifferent_access
+
+    def self.valid_comparator?(comparator)
+      @@scalar_input.key?(comparator) || @@multi_input.key?(comparator)
+    end
+
+    def self.invalid_comparator?(comparator)
+      !valid_comparator?(comparator)
+    end
+
+    def initialize(comparator, value, field, type)
+      key = prepare_comparator(comparator, value)
+      val = prepare_value(value, type)
+      if clause = @@scalar_input[key]
+        @sql = scalar_sql(clause, field, val)
+      elsif clause = @@multi_input[key]
+        @sql = multi_sql(clause, val, field, type)
+      else
+        raise ArgumentError.new("Invalid comparator: #{key}")
+      end
+    end
+
+    private
+    def prepare_comparator(comparator, value)
+
+      if value.nil? and comparator == 'is'
+        comparator = :null
+      end
+
+      return comparator
+
+    end
+
+    def prepare_value(value, type)
+      type == :boolean && !!value != value ? @@booleans[value] : value
+    end
+
+    def scalar_sql(clause, field, value)
+      clause.sub('__FIELD__', field).sub('__VALUE__', ActiveRecord::Base.connection.quote(value))
+    end
+
+    def multi_sql(clause, value, field, type)
+      values = [*value].map { |v| ActiveRecord::Base.connection.quote(v) }.join(',')
+      [clause.sub('__FIELD__', field).sub('__VALUES__', values).sub('__TYPE__', @@types[type])].compact.join
+    end
+  end
+end

data/lib/fastapi/conversions.rb

@@ -0,0 +1,32 @@
+module FastAPI
+  module Conversions
+
+    def self.convert_type(val, type, field = nil)
+      if val && is_array(field)
+        Oj.load(val).map { |inner_value| convert_value(inner_value, type) }
+      else
+        convert_value(val, type)
+      end
+    end
+
+    private
+    def self.is_array(field)
+      field && field.respond_to?('array') && field.array
+    end
+
+    def self.convert_value(val, type)
+      if val
+        case type
+        when :integer
+          val.to_i
+        when :float
+          val.to_f
+        when :boolean
+          { 't' => true, 'f' => false }[val]
+        else
+          val
+        end
+      end
+    end
+  end
+end

data/lib/fastapi/{active_record_extension.rb → extension.rb}

@@ -1,6 +1,4 @@
-require 'active_record'
-
-module FastAPIExtension
+module Extension
 
   extend ActiveSupport::Concern
 
@@ -68,9 +66,9 @@ module FastAPIExtension
     end
 
     def fastapi
-      FastAPI.new(self)
+      FastAPI::Wrapper.new(self)
     end
   end
 end
 
-ActiveRecord::Base.send(:include, FastAPIExtension)
+ActiveRecord::Base.send(:include, Extension)

data/lib/fastapi/sql.rb

@@ -0,0 +1,166 @@
+require 'forwardable'
+
+module FastAPI
+  class SQL
+    extend Forwardable
+
+    def_delegator :@sql, :[]
+
+    def initialize(filters, offset, count, klazz, whitelist, safe = false)
+
+      results = filter_fields(klazz, whitelist)
+      models, belongs, has_many, fields = results.values_at(:models, :belongs, :has_many, :fields)
+
+      model_name = klazz.to_s.tableize.singularize
+      table_name = klazz.to_s.tableize
+
+      # Base fields
+      field_list = generate_field_list(klazz, fields, table_name)
+
+      # Belongs fields
+      joins = parse_belongs(belongs, field_list, table_name)
+
+      # Many fields (1 to many)
+      parse_manys(has_many, filters, field_list, model_name, table_name)
+
+      filter_string = filters[:main].size > 0 ? "WHERE #{filters[:main].join(' AND ')}" : nil
+      order_string  = filters[:main_order] ? "ORDER BY #{filters[:main_order]}" : nil
+
+      @sql = {
+        query: [
+          "SELECT #{field_list.join(', ')}",
+          "FROM #{table_name}",
+          joins.join(' '),
+          filter_string,
+          order_string,
+          "LIMIT #{count}",
+          "OFFSET #{offset}"
+        ].compact.join(' '),
+        count_query: [
+          "SELECT COUNT(id) FROM #{table_name}",
+          filter_string
+        ].compact.join(' '),
+        models: models
+      }
+    end
+
+    private
+    def filter_fields(klazz, whitelist)
+      skeleton = { models: {}, belongs: [], has_many: [], fields: [] }
+      (klazz.fastapi_fields + whitelist).each_with_object(skeleton) do |field, results|
+
+        if klazz.reflect_on_all_associations(:belongs_to).map(&:name).include?(field)
+
+          class_name = klazz.reflect_on_association(field).options[:class_name]
+          model      = constantize_model(class_name, field)
+
+          results[:models][field] = model
+          results[:belongs] << { model: model, alias: field, type: :belongs_to }
+
+        elsif klazz.reflect_on_all_associations(:has_one).map(&:name).include?(field)
+
+          class_name = klazz.reflect_on_association(field).options[:class_name]
+          model      = constantize_model(class_name, field)
+
+          results[:models][field] = model
+          results[:belongs] << { model: model, alias: field, type: :has_one }
+
+        elsif klazz.reflect_on_all_associations(:has_many).map(&:name).include?(field)
+
+          model = field.to_s.singularize.classify.constantize
+
+          results[:models][field] = model
+          results[:has_many] << model
+
+        elsif klazz.column_names.include?(field.to_s)
+          results[:fields] << field
+        end
+
+      end
+    end
+
+    def generate_field_list(klazz, fields, table)
+      fields.each_with_object([]) do |field, list|
+        if klazz.columns_hash[field.to_s].array
+          list << "ARRAY_TO_JSON(#{table}.#{field}) AS #{field}"
+        else
+          list << "#{table}.#{field} AS #{field}"
+        end
+      end
+    end
+
+    def parse_belongs(belongs, field_list, model_table_name)
+      belongs.each_with_object([]) do |model_data, join_list|
+
+        table_name  = model_data[:model].to_s.tableize
+        table_alias = model_data[:alias].to_s.pluralize
+
+        field_name          = model_data[:alias].to_s
+        singular_table_name = model_table_name.singularize
+
+        model_data[:model].fastapi_fields_sub.each do |field|
+          if model_data[:model].columns_hash[field.to_s].array
+            field_list << "ARRAY_TO_JSON(#{table_alias}.#{field}) AS #{field_name}__#{field}"
+          else
+            field_list << "#{table_alias}.#{field} AS #{field_name}__#{field}"
+          end
+        end
+
+        # fields
+        if model_data[:type] == :belongs_to
+          # joins
+          join_list << "LEFT JOIN #{table_name} AS #{table_alias} " \
+                       "ON #{table_alias}.id = #{model_table_name}.#{field_name}_id"
+        elsif model_data[:type] == :has_one
+          join_list << "LEFT JOIN #{table_name} AS #{table_alias} " \
+                       "ON #{table_alias}.#{singular_table_name}_id = #{model_table_name}.id"
+        end
+      end
+    end
+
+    def parse_manys(has_many, filters, field_list, model_name, table_name)
+      has_many.each do |model|
+
+        model_string_table = model.to_s.tableize
+        model_symbol = model_string_table.to_sym
+
+        model_fields = model.fastapi_fields_sub.each_with_object([]) do |field, m_fields|
+          m_fields << "__#{model_string_table}.#{field}"
+        end
+
+        if filters[:has_many].has_key?(model_symbol)
+
+          if not filters[:has_many][model_symbol].blank?
+            has_many_filters = "AND #{filters[:has_many][model_symbol].join(' AND ')}"
+          else
+            has_many_filters = nil
+          end
+
+          if not filters[:has_many_order][model_symbol].blank?
+            has_many_order = "ORDER BY #{filters[:has_many_order][model_symbol]}"
+          else
+            has_many_order = nil
+          end
+
+        end
+
+        field_list << [
+          "ARRAY_TO_JSON(ARRAY(SELECT ROW(#{model_fields.join(', ')})",
+          "FROM #{model_string_table}",
+          "AS __#{model_string_table}",
+          "WHERE __#{model_string_table}.#{model_name}_id IS NOT NULL",
+          "AND __#{model_string_table}.#{model_name}_id",
+          "= #{table_name}.id",
+          has_many_filters,
+          has_many_order,
+          ")) AS __many__#{model_string_table}"
+        ].compact.join(' ')
+
+      end
+    end
+
+    def constantize_model(class_name, field)
+      (class_name ? class_name : field.to_s.classify).constantize
+    end
+  end
+end

data/lib/fastapi/utilities.rb

@@ -0,0 +1,7 @@
+module FastAPI
+  module Utilities
+    def clamp(value, min, max)
+      [min, value, max].sort[1]
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastapi
 version: !ruby/object:Gem::Version
-  version: 0.1.27
+  version: 0.2.0
 platform: ruby
 authors:
 - Keith Horwood
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-01 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -147,7 +147,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/fastapi.rb
-- lib/fastapi/active_record_extension.rb
+- lib/fastapi/comparison.rb
+- lib/fastapi/conversions.rb
+- lib/fastapi/extension.rb
+- lib/fastapi/sql.rb
+- lib/fastapi/utilities.rb
 homepage: https://github.com/thestorefront/FastAPI
 licenses:
 - MIT