ansr 0.0.1 → 0.0.3

data/ansr_dpla/lib/ansr_dpla/arel/query_builder.rb

@@ -1,131 +0,0 @@
-module Ansr::Dpla
-  module Arel
-    class QueryBuilder
-      attr_reader :query_opts, :aliases, :table
-      def initialize(big_table)
-        @query_opts = {}
-        @aliases = {}
-        @table = big_table
-      end
-      def fields=(value)
-        @query_opts[:fields] = value
-      end
-      def select(arel_nodes=nil)
-        arel_nodes = [arel_nodes].compact unless arel_nodes.respond_to? :each
-        arel_nodes.each.select {|an| ::Arel::SqlLiteral === an}.each do |n|
-          select_val = n.to_s.split(" AS ")
-          add_field(select_val[0])
-          aliases[select_val[0]] = select_val[1] if select_val[1]
-        end
-      end
-
-      def field_key_from_node(node)
-        table.model.field_name(node)
-      end
-
-      def add_field(field_name)
-        return unless field_name
-        query_opts[:fields] ||= ""
-        query_opts[:fields] << ',' << field_name
-        query_opts[:fields].sub!(/^,/,'')
-      end        
-
-      def add_facet(field_name)
-        return unless field_name
-        field_name = Array(field_name).uniq
-        if query_opts[:facets]
-          query_opts[:facets] = (Array(query_opts[:facets]) + field_name).uniq
-        else
-          query_opts[:facets] = field_name[1] ? field_name : field_name[0]
-        end
-      end
-
-      def where(arel_nodes)
-          arel_nodes = (arel_nodes.respond_to? :each) ? arel_nodes : Array(arel_nodes)
-        arel_nodes.each do |node|
-          case node
-            when ::Arel::Nodes::Equality
-              field_key = field_key_from_node(node.left)
-              if @query_opts[field_key]
-                @query_opts[field_key] = (Array(@query_opts[field_key]) << node.right)
-              else
-                @query_opts[field_key] = node.right
-              end
-            when ::Arel::Nodes::Grouping
-              n = node.expr
-              if ::Arel::Nodes::Binary === n
-                prefix = nil
-                prefix = "NOT" if (::Arel::Nodes::NotEqual === n)
-                prefix = "OR" if (::Arel::Nodes::Or === n)
-                if prefix
-                  val = "#{prefix} #{n.right}"
-                else
-                  val = n.right
-                end
-                field_key = field_key_from_node(n)
-                if @query_opts[field_key]
-                  @query_opts[field_key] = Array(@query_opts[field_key]) << val
-                else
-                  @query_opts[field_key] = val
-                end
-              end
-            when ::Arel::Attributes::Attribute # this is the field references
-          end
-        end
-      end
-
-      def order(*arel_nodes)
-        direction = nil
-        nodes = []
-        arel_nodes.inject(nodes) do |c, n|
-          if ::Arel::Nodes::Ordering === n
-            c << n
-          elsif n.is_a? String
-            _ns = n.split(',')
-            _ns.each do |_n| 
-              _p = _n.split(/\s+/)
-              if (_p[1])
-                _p[1] = _p[1].downcase.to_sym
-              else
-                _p[1] = :asc
-              end
-              c << table[_p[0].to_sym].send(_p[1])
-            end
-          end
-          c
-        end
-        nodes.each do |node|
-          if ::Arel::Nodes::Ordering === node
-            if @query_opts[:sort_by]
-              @query_opts[:sort_by] = Array[@query_opts[:sort_by]] << node.expr.name
-            else
-              @query_opts[:sort_by] = node.expr.name
-            end
-            direction = :asc if (::Arel::Nodes::Ascending === node and direction)
-            direction = :desc if (::Arel::Nodes::Descending === node)
-          end
-        end
-        @query_opts[:sort_order] = direction if direction
-      end
-
-      def take(value=nil)
-        if value and (value = value.to_i)
-          raise "Page size cannot be > 500 (#{value}" if value > 500
-          @query_opts[:page_size] = value
-        end
-      end
-
-      def skip(value=nil)
-        if value
-          @query_opts[:page] = (value.to_i / (@query_opts[:page_size] || Ansr::Relation::DEFAULT_PAGE_SIZE)) + 1
-        end
-      end
-
-      def filters=(values)
-        unless values.empty?
-          @query_opts[:facets] = (values[1]) ? values : values[0]
-        end
-      end
-    end
-  end
-end

data/lib/ansr/model/connection.rb

@@ -1,103 +0,0 @@
-module Ansr
-	module Model
-    class Connection
-      def initialize(klass)
-        @table = klass.table
-      end
-
-      def primary_key(table_name)
-        'id'
-      end
-
-      def limit(arel_node)
-        case arel_node
-        when ::Arel::SelectManager
-          arel_node.limit
-        when ::Arel::Nodes::SelectStatement
-          arel_node.limit && arel_node.limit.expr
-        else
-          nil
-        end
-      end
-
-      def offset(arel_node)
-        case arel_node
-        when ::Arel::SelectManager
-          arel_node.offset
-        when ::Arel::Nodes::SelectStatement
-          arel_node.offset && arel_node.offset.expr
-        else
-          nil
-        end
-      end
-
-      def constraints(arel_node)
-        case arel_node
-        when ::Arel::SelectManager
-          arel_node.constraints
-        when ::Arel::Nodes::SelectStatement
-          arel_node.cores.last.wheres
-        else
-          nil
-        end
-      end
-
-      def projections(arel_node)
-        case arel_node
-        when ::Arel::SelectManager
-          arel_node.projections
-        when ::Arel::Nodes::SelectStatement
-          arel_node.cores.last.projections
-        else
-          nil
-        end
-      end        
-
-      def orders(arel_node)
-        case arel_node
-        when ::Arel::SelectManager
-          arel_node.orders
-        when ::Arel::Nodes::SelectStatement
-          arel_node.orders
-        else
-          nil
-        end
-      end        
-
-      def schema_cache
-        ActiveRecord::ConnectionAdapters::SchemaCache.new(self)
-      end
-
-      def table_exists?(table_name)
-        true
-      end
-
-      # this is called by the BigTable impl
-      def columns(table_name, *rest)
-        @table.fields.map {|s| ::ActiveRecord::ConnectionAdapters::Column.new(s.to_s, nil, nil)}
-      end
-
-      def sanitize_limit(limit_value)
-        if limit_value.to_s.to_i >= 0
-          limit_value
-        else
-          Ansr::Relation::DEFAULT_PAGE_SIZE
-        end
-      end
-
-      def sanitize_filter_name(filter_value)
-        if filter_value.is_a? Array
-          return filter_value.collect {|x| sanitize_filter_name(x)}.compact
-        else
-          if @table.facets.include? filter_value.to_sym
-            return filter_value
-          else
-            raise "#{filter_value} is not a facetable field"
-            #Rails.logger.warn "Ignoring #{filter_value} (not a filterable field)" if Rails.logger
-            #return nil
-          end
-        end
-      end
-    end
-  end
-end