directiverecord 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjYwOWJkMDk4YmUyZWZkMjcwMThiZDk4NzQ1ZTUzMzJiM2YwYzg1NQ==
+  data.tar.gz: !binary |-
+    YjA3MDE0YmRjYjA4NTc3NjMyYmZkOGEzMTc4NGUzMjk2NGMwYzgwOQ==
+SHA512:
+  metadata.gz: !binary |-
+    YmUxZGI1YmYxNWIzMjMyOGM5MWY2NmFmYWMxZGRlOTEyZjFmYjI3ZWE1Mjdk
+    M2MwNGIxYzIzMmYwZWU5ZTNiMGJjZmQ5MmRhNjNjNjAyNzdiNmVmZjk2NjYy
+    NmU4YTc1ODg4OWFkMmRkZmVhMzQ3MjAxMTc1ZmFiNjZmNTI4YzA=
+  data.tar.gz: !binary |-
+    YzdiM2Q0ZDI2ODFmMGJiNWNiY2M3MWU1ODQzMjUwMWViZDMxNWU2NzRkYmEy
+    MTBhZTMyN2YyMTVhZWZjOTU4NGYxMjBiYmRjZDg1YTExYTYyNDRkNTVhNTRh
+    YjJjZDhjNDFmZDAyMjgxOWZmYzdjY2Y1NDMyN2RhZDQ4NTA4MjM=

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+.bundle
+.yardoc
+.rvmrc
+Gemfile.lock
+doc
+pkg
+*.log
+test/coverage

data/CHANGELOG.rdoc

@@ -0,0 +1,5 @@
+= DirectiveRecord CHANGELOG
+
+== Version 0.1.0 (December 1, 2014)
+
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Paul Engel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+## DirectiveRecord
+
+A layer on top of ActiveRecord for using paths within queries without thinking about association joins
+
+### Installation
+
+Add `DirectiveRecord` in your `Gemfile`:
+
+    gem "directiverecord"
+
+Run the following in your console to install with Bundler:
+
+    $ bundle install
+
+### Demo
+
+To try `DirectiveRecord` right out-of-the-box, please clone
+
+https://github.com/archan937/directiverecord-console
+
+and follow the README instructions. It is provided with a sample database and a Pry console in which you can play with `DirectiveRecord`.
+
+The README is also provided with several [straightforward examples](https://github.com/archan937/directiverecord-console#using-the-console).
+
+### Testing
+
+Run the following command for testing:
+
+    $ rake
+
+You can also run a single test file:
+
+    $ ruby test/unit/query/test_mysql.rb
+
+### TODO
+
+* Add more tests
+
+### License
+
+Copyright (c) 2014 Paul Engel, released under the MIT License
+
+http://github.com/archan937 – http://twitter.com/archan937 – http://gettopup.com – pm_engel@icloud.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new do |test|
+  test.pattern = "test/**/test_*.rb"
+end

data/VERSION

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

data/directiverecord.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/directive_record/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.author        = "Paul Engel"
+  gem.email         = "pm_engel@icloud.com"
+  gem.summary       = %q{A layer on top of ActiveRecord for using paths within queries without thinking about association joins}
+  gem.description   = %q{A layer on top of ActiveRecord for using paths within queries without thinking about association joins}
+  gem.homepage      = "https://github.com/archan937/directiverecord"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "directiverecord"
+  gem.require_paths = ["lib"]
+  gem.version       = DirectiveRecord::VERSION
+
+  gem.add_dependency "activerecord", ">= 4.0"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "yard"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "mysql2"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "mocha"
+end

data/lib/directive_record.rb

@@ -0,0 +1,6 @@
+require "active_record"
+
+require "directive_record/gem_ext"
+require "directive_record/relation"
+require "directive_record/query"
+require "directive_record/version"

data/lib/directive_record/gem_ext.rb

@@ -0,0 +1 @@
+require "directive_record/gem_ext/active_record"

data/lib/directive_record/gem_ext/active_record.rb

@@ -0,0 +1,2 @@
+require "directive_record/gem_ext/active_record/base"
+require "directive_record/gem_ext/active_record/relation"

data/lib/directive_record/gem_ext/active_record/base.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  class Base
+
+    def self.to_qry(*args)
+      DirectiveRecord::Query.new(self).to_sql(*args)
+    end
+
+    def self.qry(*args)
+      connection.select_rows to_qry(*args)
+    end
+
+  end
+end

data/lib/directive_record/gem_ext/active_record/relation.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  class Relation
+
+    def qry_options(*args)
+      DirectiveRecord::Relation.new(self).qry_options(*args)
+    end
+
+    def to_qry(*args)
+      klass.to_qry qry_options(*args)
+    end
+
+    def qry(*args)
+      klass.qry qry_options(*args)
+    end
+
+  end
+end

data/lib/directive_record/query.rb

@@ -0,0 +1,25 @@
+require "directive_record/query/sql"
+require "directive_record/query/mysql"
+require "directive_record/query/monetdb"
+
+module DirectiveRecord
+  module Query
+
+    def self.new(klass)
+      class_for(klass.connection.class.name.downcase).new(klass)
+    end
+
+  private
+
+    def self.class_for(connection_class)
+      if connection_class.include?("mysql")
+        MySQL
+      elsif connection_class.include?("monetdb")
+        MonetDB
+      else
+        raise NotImplementedError
+      end
+    end
+
+  end
+end

data/lib/directive_record/query/monetdb.rb

@@ -0,0 +1,54 @@
+module DirectiveRecord
+  module Query
+    class MonetDB < SQL
+
+    private
+
+      def path_delimiter
+        "__"
+      end
+
+      def aggregate_delimiter
+        "__"
+      end
+
+      def group_by_all_sql
+        "all_rows"
+      end
+
+      def prepare_options!(options)
+        normalize_group_by! options
+        [:select, :where, :having, :group_by, :order_by].each do |key|
+          if options[key]
+            base.reflections.keys.each do |association|
+              options[key] = [options[key]].flatten.collect{|x| x.gsub(/^#{association}\.([a-z_\.]+)/) { "#{association}_#{$1.gsub(".", "_")}" }}
+            end
+          end
+        end
+      end
+
+      def finalize_options!(options)
+        if options[:having]
+          if options[:numerize_aliases]
+            map = Hash[options[:select].scan(/,?\s?(.*?) AS ([^,]+)/).collect(&:reverse)]
+            options[:aliases].each{|pattern, replacement| options[:having].gsub! pattern, map[replacement]}
+          else
+            (options[:aggregates] || {}).each do |path, aggregate|
+              options[:having].gsub! /\b#{aggregate}__#{path}\b/, "#{aggregate.to_s.upcase}(#{path})"
+            end
+          end
+        end
+
+        options[:select] = options[:select].split(", ").collect do |string|
+          expression, query_alias = string.match(/^(.*) AS (.*)$/).try(:captures)
+          if query_alias
+            options[:group_by].to_s.include?(expression) || !expression.match(/^\w+(\.\w+)*$/) ? string : "MAX(#{expression}) AS #{query_alias}"
+          else
+            string.match(/^\w+(\.\w+)*$/) ? "MAX(#{string})" : string
+          end
+        end.join(", ") if options[:group_by]
+      end
+
+    end
+  end
+end

data/lib/directive_record/query/mysql.rb

@@ -0,0 +1,36 @@
+module DirectiveRecord
+  module Query
+    class MySQL < SQL
+
+    private
+
+      def path_delimiter
+        "."
+      end
+
+      def aggregate_delimiter
+        ":"
+      end
+
+      def group_by_all_sql
+        "NULL"
+      end
+
+      def quote_alias(sql_alias)
+        "`#{sql_alias}`"
+      end
+
+      def finalize_options!(options)
+        return unless options[:numerize_aliases]
+        [:group_by, :having, :order_by].each do |key|
+          if sql = options[key]
+            options[:aliases].each do |pattern, replacement|
+              sql.gsub! pattern, replacement
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/directive_record/query/sql.rb

@@ -0,0 +1,291 @@
+module DirectiveRecord
+  module Query
+    class SQL
+
+      def initialize(base)
+        @base = base
+      end
+
+      def to_sql(*args)
+        options = extract_options(args)
+        validate_options! options
+
+        optimize_query! options
+
+        prepare_options! options
+        normalize_options! options
+
+        parse_joins! options
+
+        prepend_base_alias! options
+        finalize_options! options
+
+        compose_sql options
+      end
+
+    private
+
+      def path_delimiter
+        raise NotImplementedError
+      end
+
+      def aggregate_delimiter
+        raise NotImplementedError
+      end
+
+      def group_by_all_sql
+        raise NotImplementedError
+      end
+
+      def select_aggregate_sql(method, path)
+        "#{method.to_s.upcase}(#{path})"
+      end
+
+      def select_aggregate_sql_alias(method, path)
+        quote_alias("#{method}#{aggregate_delimiter}#{path}")
+      end
+
+      def base
+        @base
+      end
+
+      def base_alias
+        @base_alias ||= quote_alias(base.table_name.split("_").collect{|x| x[0]}.join(""))
+      end
+
+      def quote_alias(sql_alias)
+        sql_alias
+      end
+
+      def extract_options(args)
+        options = args.extract_options!.deep_dup
+        options.reverse_merge! :select => (args.empty? ? "*" : args)
+        options
+      end
+
+      def validate_options!(options)
+        options.assert_valid_keys :select, :where, :group_by, :order_by, :limit, :offset, :aggregates, :numerize_aliases
+      end
+
+      def optimize_query!(options)
+        select = [options[:select]].flatten
+        if options[:where] && (select != %w(id)) && select.any?{|x| x.match(/^\w+(\.\w+)+$/)}
+          ids = base.connection.select_values(to_sql(options.merge(:select => "id"))).uniq + [0]
+          options[:where] = ["id IN (#{ids.join(", ")})"]
+          options.delete :limit
+          options.delete :offset
+        end
+      end
+
+      def prepare_options!(options); end
+
+      def normalize_options!(options)
+        normalize_select!(options)
+        normalize_where!(options)
+        normalize_group_by!(options)
+        normalize_order_by!(options)
+        options.reject!{|k, v| v.blank?}
+      end
+
+      def normalize_select!(options)
+        select = to_array! options, :select
+        select.uniq!
+
+        options[:scales] = select.inject({}) do |hash, sql|
+          if scale = column_for(sql).try(:scale)
+            hash[sql] = scale
+          end
+          hash
+        end
+
+        options[:aggregated] = {}
+        options[:aliases] = {}
+
+        options[:select] = options[:select].inject([]) do |array, path|
+          sql, sql_alias = ((path == ".*") ? "#{base_alias}.*" : path), nil
+
+          if aggregate_method = (options[:aggregates] || {})[path]
+            sql = select_aggregate_sql(aggregate_method, path)
+            sql_alias = options[:aggregated][path] = select_aggregate_sql_alias(aggregate_method, path)
+          end
+          if scale = options[:scales][path]
+            sql = "ROUND(#{sql}, #{scale})"
+            sql_alias ||= quote_alias(path)
+          end
+          if options[:numerize_aliases]
+            sql = sql.gsub(/ AS .*$/, "")
+            sql_alias = options[:aliases][prepend_base_alias(sql_alias || sql)] = "c#{array.size + 1}"
+          end
+
+          array << [sql, sql_alias].compact.join(" AS ")
+          array
+        end
+      end
+
+      def normalize_where!(options)
+        regexp = /^\S+/
+
+        where, having = (to_array!(options, :where) || []).partition do |statement|
+          !options[:aggregated].keys.include?(statement.strip.match(regexp).to_s) &&
+          statement.downcase.gsub(/((?<![\\])['"])((?:.(?!(?<![\\])\1))*.?)\1/, " ")
+                            .scan(/([a-zA-Z_\.]+)?\s*(=|<=>|>=|>|<=|<|<>|!=|is|like|rlike|regexp|in|between|not|sounds|soundex)(\b|\s)/)
+                            .all? do |(path, operator)|
+            path && column_for(path)
+          end
+        end
+
+        unless (attrs = base.scope_attributes).blank?
+          sql = base.send(:sanitize_sql_for_conditions, attrs, "").gsub(/``.`(\w+)`/) { $1 }
+          where << sql
+        end
+
+        options[:where], options[:having] = where, having.collect do |statement|
+          statement.strip.gsub(regexp){|path| options[:aggregated][path] || path}
+        end
+
+        [:where, :having].each do |key|
+          value = options[key]
+          options[key] = (value.collect{|x| "(#{x})"}.join(" AND ") unless value.empty?)
+        end
+      end
+
+      def normalize_group_by!(options)
+        group_by = to_array! options, :group_by
+        group_by.clear.push(group_by_all_sql) if group_by == [:all]
+      end
+
+      def normalize_order_by!(options)
+        options[:order_by] ||= (options[:group_by] || []).collect do |path|
+          direction = "DESC" if path.to_s == "date"
+          "#{path} #{direction}".strip
+        end
+
+        to_array!(options, :order_by).collect! do |x|
+          segments = x.split " "
+          direction = segments.pop if %w(asc desc).include?(segments[-1].downcase)
+          path = segments.join " "
+
+          if path != group_by_all_sql
+            scale = options[:scales][path]
+            select = begin
+              if aggregate_method = (options[:aggregates] || {})[path]
+                select_aggregate_sql(aggregate_method, path)
+              else
+                path
+              end
+            end
+            "#{scale ? "ROUND(#{select}, #{scale})" : select} #{direction.upcase if direction}".strip
+          end
+        end
+
+        options[:order_by].compact!
+      end
+
+      def to_array!(options, key)
+        if value = options[key]
+          options[key] = [value].flatten
+        end
+      end
+
+      def column_for(path)
+        segments = path.split(".")
+        column = segments.pop
+        model = segments.inject(base) do |klass, association|
+          klass.reflect_on_association(association.to_sym).klass
+        end
+        model.columns_hash[column]
+      rescue
+        nil
+      end
+
+      def parse_joins!(options)
+        return if (paths = extract_paths(options)).empty?
+
+        regexp = /INNER JOIN `([^`]+)`( `[^`]+`)? ON `[^`]+`.`([^`]+)` = `[^`]+`.`([^`]+)`/
+
+        options[:joins] = paths.collect do |path|
+          joins, associations = [], []
+          path.split(".").inject(base) do |klass, association|
+            association = association.to_sym
+
+            table_joins = klass.joins(association).to_sql.scan regexp
+            concerns_bridge_table = table_joins.size == 2
+            bridge_table_as = nil
+
+            table_joins.each_with_index do |table_join, index|
+              concerns_bridge_table_join = concerns_bridge_table && index == 0
+              join_table, possible_alias, join_table_column, table_column = table_join
+
+              table_as = (klass == base) ? base_alias : quote_alias(associations.join(path_delimiter))
+              join_table_as = quote_alias((associations + [association]).join(path_delimiter))
+
+              if concerns_bridge_table
+                if concerns_bridge_table_join
+                  join_table_as = bridge_table_as = quote_alias("#{(associations + [association]).join(path_delimiter)}_bridge_table")
+                else
+                  table_as = bridge_table_as
+                end
+              end
+
+              joins.push "LEFT JOIN #{join_table} #{join_table_as} ON #{join_table_as}.#{join_table_column} = #{table_as}.#{table_column}"
+            end
+
+            associations << association
+            klass.reflect_on_association(association).klass
+          end
+          joins
+        end.flatten.uniq.join("\n")
+      end
+
+      def extract_paths(options)
+        [:select, :where, :group_by, :having, :order_by].inject([]) do |paths, key|
+          if value = options[key]
+            value = value.join " " if value.is_a?(Array)
+            paths.concat value.gsub(/((?<![\\])['"])((?:.(?!(?<![\\])\1))*.?)\1/, " ").scan(/[a-zA-Z_]+\.[a-zA-Z_\.]+/).collect{|x| x.split(".")[0..-2].join "."}
+          else
+            paths
+          end
+        end.uniq
+      end
+
+      def prepend_base_alias!(options)
+        [:select, :where, :group_by, :having, :order_by].each do |key|
+          if value = options[key]
+            options[key] = prepend_base_alias value, options[:aliases]
+          end
+        end
+      end
+
+      def prepend_base_alias(sql, aliases = {})
+        columns = base.columns_hash.keys
+        sql = sql.join ", " if sql.is_a?(Array)
+        sql.gsub(/("[^"]*"|'[^']*'|`[^`]*`|[a-zA-Z_#{aggregate_delimiter}]+(\.[a-zA-Z_\*]+)*)/) do
+          columns.include?($1) ? "#{base_alias}.#{$1}" : begin
+            if (string = $1).match /^([a-zA-Z_\.]+)\.([a-zA-Z_\*]+)$/
+              path, column = $1, $2
+              "#{quote_alias path.gsub(".", path_delimiter)}.#{column}"
+            else
+              string
+            end
+          end
+        end
+      end
+
+      def finalize_options!(options); end
+
+      def compose_sql(options)
+        sql = ["SELECT #{options[:select]}", "FROM #{base.table_name} #{base_alias}", options[:joins]].compact
+
+        [:where, :group_by, :having, :order_by, :limit, :offset].each do |key|
+          unless (value = options[key]).blank?
+            keyword = key.to_s.upcase.gsub("_", " ")
+            sql << "#{keyword} #{value}"
+          end
+        end
+
+        sql.join "\n"
+      end
+
+    end
+  end
+end