magick_columns 0.0.1 → 0.0.2

data/README.md

@@ -0,0 +1,93 @@
+# MagickColumns
+
+This gem extends ActiveRecord to provide queries built from *simple* strings
+
+## Instalation
+
+Add to your Gemfile:
+
+```ruby
+gem 'magick_columns'
+```
+
+## Usage
+
+You must declare `has_magick_columns` in your model:
+
+```ruby
+class Person < ActiveRecord::Base
+  has_magick_columns name: :string, email: :email, birth: :date
+end
+```
+
+And now you can do something like this:
+
+```ruby
+people = Person.magick_search('anakin or luke')
+```
+
+The method returns a Relation, so you can apply any aditional method you want:
+
+```ruby
+people.order('name').limit(5)
+```
+
+And of course you can "spy" the query with:
+
+```ruby
+people.to_sql
+```
+
+## Rules
+
+There is also a set of rules, for tokenize and replace some types of "patterns".
+For example, you can write:
+
+```ruby
+people = Person.magick_search('from 01/01/2000')
+```
+
+And you get the people born in the XXI century =)
+
+## Custom configuration
+
+If you want to define your own rules, or replace some existing configuration add
+in config/initializers one ruby file, for example magick_columns_config.rb
+
+```ruby
+MagickColumns.setup do |config|
+  config.and_operators = ['and']
+  config.or_operators = ['or']
+  config.from_operators = ['from', 'since']
+  config.until_operators = ['to', 'until']
+  config.today_operators = ['today', 'now']
+  # Each replacement rule consists in a pattern and a replacement proc or lambda
+  config.replacement_rules[:new_replacement_rule] =
+    pattern: /today/,
+    replacement: ->(match) { Date.today.to_s(:db) }
+  }
+  # Each tokenizer rule consists in a pattern and a tokenizer proc or lambda.
+  # The proc must return a hash with a valid SQL operator and a term for the
+  # condition.
+  config.tokenize_rules[:new_tokenize_rule] = {
+    pattern: /(\A\s*|\s+)(from|since)\s+(\S+)/,
+    tokenizer: ->(match) { { operator: '>=', term: match[3] } }
+  }
+end
+```
+
+## How to contribute
+
+If you find what you might think is a bug:
+
+1. Check the GitHub issue tracker to see if anyone else has had the same issue.
+   https://github.com/francocatena/magick_columns/issues/
+2. If you do not see anything, create an issue with information on how to reproduce it.
+
+If you want to contribute an enhancement or a fix:
+
+1. Fork the project on GitHub.
+   https://github.com/francocatena/magick_columns/
+2. Make your changes with tests.
+3. Commit the changes without making changes to the Rakefile, VERSION, or any other files that are not related to your enhancement or fix
+4. Send a pull request.

data/lib/magick_columns.rb

@@ -1,6 +1,58 @@
-require 'magick_columns/magick_columns'
-require 'magick_columns/defaults'
+module MagickColumns
+  autoload :DEFAULTS, 'magick_columns/defaults'
+  autoload :I18N_DEFAULTS, 'magick_columns/defaults'
+  autoload :TOKENIZE_RULES, 'magick_columns/rules'
+  autoload :REPLACEMENT_RULES, 'magick_columns/rules'
+  autoload :Tokenizer, 'magick_columns/tokenizer'
+  
+  class << self
+    private
 
-autoload 'Timeliness', 'timeliness'
+    def _default_setup_for(config)
+      translation = I18n.t("magick_columns.#{config}", raise: true) rescue MagickColumns::I18N_DEFAULTS[config]
 
-ActiveRecord::Base.send :include, MagickColumns::Base
+      if translation.respond_to?(:map)
+        translation.map { |c| Regexp.quote(c) }.join('|')
+      else
+        translation
+      end
+    end
+  end
+  
+  # Strings considered "and" spliters
+  mattr_accessor :and_operators
+  @@and_operators = _default_setup_for :and
+  
+  # Strings considered "or" spliters
+  mattr_accessor :or_operators
+  @@or_operators = _default_setup_for :or
+  
+  # Strings considered "from" terms (like "from 01/01/2012")
+  mattr_accessor :from_operators
+  @@from_operators = _default_setup_for :from
+  
+  # Strings considered "until" terms (like "until 01/01/2012")
+  mattr_accessor :until_operators
+  @@until_operators = _default_setup_for :until
+  
+  # Strings considered "today" strings (like "from today")
+  mattr_accessor :today_operators
+  @@today_operators = _default_setup_for :today
+  
+  # Rules to replace text in the natural string
+  mattr_accessor :replacement_rules
+  @@replacement_rules = REPLACEMENT_RULES.dup
+  
+  # Rules for tokenize the natural string
+  mattr_accessor :tokenize_rules
+  @@tokenize_rules = TOKENIZE_RULES.dup
+  
+  # Setup method for plugin configuration
+  def self.setup
+    yield self
+  end
+end
+
+autoload :Timeliness, 'timeliness'
+
+require 'magick_columns/railtie' if defined?(Rails)

data/lib/magick_columns/active_record.rb

@@ -0,0 +1,56 @@
+module MagickColumns
+  module ActiveRecord
+    def has_magick_columns(options = {})
+      @@_magick_columns ||= {}
+      @@_magick_columns[name] ||= []
+
+      options.each do |field, type|
+        column_options = _magick_column_options(type)
+
+        @@_magick_columns[name] << { field: field }.merge(column_options)
+      end
+    end
+
+    def magick_search(query)
+      or_queries = []
+      terms = {}
+
+      MagickColumns::Tokenizer.new(query).extract_terms.each_with_index do |or_term, i|
+        and_queries = []
+
+        or_term.each_with_index do |and_term, j|
+          mini_query = []
+
+          @@_magick_columns[name].each_with_index do |column, k|
+            if column[:condition].call(and_term[:term])
+              operator = and_term[:operator] || _map_magick_column_operator(column[:operator])
+              terms[:"t_#{i}_#{j}_#{k}"] = column[:mask] % {t: and_term[:term]}
+
+              mini_query << "#{column[:field]} #{operator} :t_#{i}_#{j}_#{k}"
+            end
+          end
+
+          and_queries << mini_query.join(' OR ')
+        end
+
+        or_queries << and_queries.map { |a_q| "(#{a_q})" }.join(' AND ')
+      end
+
+      where(or_queries.map { |o_q| "(#{o_q})" }.join(' OR '), terms)
+    end
+
+    private
+
+    def _magick_column_options(type)
+      type.kind_of?(Hash) ? type : MagickColumns::DEFAULTS[type.to_sym]
+    end
+
+    def _map_magick_column_operator(operator, db = nil)
+      db ||= ::ActiveRecord::Base.connection.adapter_name
+
+      operator == :like ? (db == 'PostgreSQL' ? 'ILIKE' : 'LIKE') : operator
+    end
+  end
+end
+
+ActiveRecord::Base.extend MagickColumns::ActiveRecord

data/lib/magick_columns/defaults.rb

@@ -1,4 +1,4 @@
-module MagicColumns
+module MagickColumns
   DEFAULTS = {
     string: {
       operator: :like,
@@ -28,4 +28,12 @@ module MagicColumns
       convert: ->(t) { ::Timeliness.parse(t.to_s) }
     }
   }
+  
+  I18N_DEFAULTS = {
+    from: ['from', 'since'],
+    until: ['to', 'until'],
+    and: ['and'],
+    or: ['or'],
+    today: ['today', 'now']
+  }
 end

data/lib/magick_columns/locale/en.yml

@@ -0,0 +1,15 @@
+'en':
+  magick_columns:
+    and:
+      - and
+    or:
+      - or
+    from:
+      - from
+      - since
+    until:
+      - to
+      - until
+    today:
+      - today
+      - now

data/lib/magick_columns/locale/es.yml

@@ -0,0 +1,13 @@
+'es':
+  magick_columns:
+    and:
+      - y
+    or:
+      - o
+    from:
+      - desde
+    until:
+      - hasta
+    today:
+      - hoy
+      - ahora

data/lib/magick_columns/railtie.rb

@@ -0,0 +1,9 @@
+module MagickColumns
+  class Railtie < Rails::Railtie
+    initializer 'magick_columns.active_record' do
+      ActiveSupport.on_load :active_record do
+        require 'magick_columns/active_record'
+      end
+    end
+  end
+end

data/lib/magick_columns/rules.rb

@@ -0,0 +1,20 @@
+# TODO: These rules should be added to a live array, not a constant one
+module MagickColumns
+  TOKENIZE_RULES = {
+    from: {
+      pattern: /(\A\s*|\s+)(#{MagickColumns.from_operators})\s+(\S+)/,
+      tokenizer: ->(match) { { operator: '>=', term: match[3] } }
+    },
+    until:{
+      pattern: /(\A\s*|\s+)(#{MagickColumns.until_operators})\s+(\S+)/,
+      tokenizer: ->(match) { { operator: '<=', term: match[3] } }
+    }
+  }
+  
+  REPLACEMENT_RULES = {
+    today: {
+      pattern: /#{MagickColumns.today_operators}/,
+      replacement: ->(match) { Date.today.to_s(:db) }
+    }
+  }
+end

data/lib/magick_columns/tokenizer.rb

@@ -0,0 +1,56 @@
+module MagickColumns
+  class Tokenizer
+    def initialize(query = '')
+      @query = query
+    end
+    
+    def extract_terms
+      terms = []
+
+      clean_query.split(%r{\s+(#{MagickColumns.or_operators})\s+}).each do |o_t|
+        unless o_t =~ %r{\A(#{MagickColumns.or_operators})\z}
+          and_terms = []
+          
+          o_t.split(%r{\s+(#{MagickColumns.and_operators})\s+}).each do |t|
+            unless t =~ %r{\A(#{MagickColumns.and_operators})\z}
+              and_terms.concat split_term_in_terms(t)
+            end
+          end
+          
+          terms << and_terms unless and_terms.empty?
+        end
+      end
+
+      terms.reject(&:empty?)
+    end
+    
+    def clean_query
+      @query.strip
+        .gsub(%r{\A(\s*(#{MagickColumns.and_operators})\s+)+}, '')
+        .gsub(%r{(\s+(#{MagickColumns.and_operators})\s*)+\z}, '')
+        .gsub(%r{\A(\s*(#{MagickColumns.or_operators})\s+)+}, '')
+        .gsub(%r{(\s+(#{MagickColumns.or_operators})\s*)+\z}, '')
+    end
+    
+    def split_term_in_terms(term)
+      term_copy = term.dup
+      terms = []
+      
+      MagickColumns.replacement_rules.each do |rule, options|
+        while(match = term_copy.match(options[:pattern]))
+          term_copy.sub!(options[:pattern], options[:replacement].call(match))
+        end
+      end
+      
+      MagickColumns.tokenize_rules.each do |rule, options|
+        while(match = term_copy.match(options[:pattern]))
+          terms << options[:tokenizer].call(match)
+          
+          term_copy.sub!(options[:pattern], '')
+        end
+      end
+      
+      terms + term_copy.strip.split(/\s+/).map { |t| { term: t } }
+    end
+  end
+end

data/lib/magick_columns/version.rb

@@ -1,3 +1,3 @@
 module MagickColumns
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/test/dummy/log/development.log

@@ -116,3 +116,96 @@ Migrating to CreateArticles (20120312175442)
    (0.5ms)  SELECT version FROM "schema_migrations"
    (3.2ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120312175442')
    (10.9ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120312175303')
+   (0.6ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.1ms)  SET search_path TO public
+   (222.3ms)  DROP DATABASE IF EXISTS "dummy_test"
+   (0.2ms)  SET search_path TO public
+   (884.3ms)  CREATE DATABASE "dummy_test" ENCODING = 'unicode'
+   (145.9ms)  CREATE TABLE "articles" ("id" serial primary key, "name" character varying(255), "code" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (276.6ms)  CREATE TABLE "people" ("id" serial primary key, "name" character varying(255), "email" character varying(255), "birth" date, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (100.6ms)  CREATE TABLE "schema_migrations" ("version" character varying(255) NOT NULL) 
+   (145.3ms)   SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
+ FROM pg_class t
+ INNER JOIN pg_index d ON t.oid = d.indrelid
+ INNER JOIN pg_class i ON d.indexrelid = i.oid
+ WHERE i.relkind = 'i'
+ AND d.indisprimary = 'f'
+ AND t.relname = 'schema_migrations'
+ AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+ ORDER BY i.relname
+
+   (255.5ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.7ms)  SELECT version FROM "schema_migrations"
+   (74.6ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120312175442')
+   (52.4ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120312175303')
+   (42.1ms)  ALTER TABLE "schema_migrations" DISABLE TRIGGER ALL;ALTER TABLE "people" DISABLE TRIGGER ALL;ALTER TABLE "articles" DISABLE TRIGGER ALL
+   (0.2ms)  BEGIN
+  Fixture Delete (0.6ms)  DELETE FROM "articles"
+  Fixture Insert (26.6ms)  INSERT INTO "articles" ("name", "code", "created_at", "updated_at", "id") VALUES ('Lightsaber', 1, '2012-03-15 17:41:34', '2012-03-15 17:41:34', 980403528)
+  Fixture Insert (0.3ms)  INSERT INTO "articles" ("name", "code", "created_at", "updated_at", "id") VALUES ('Ship', 2, '2012-03-15 17:41:34', '2012-03-15 17:41:34', 976284455)
+  PK and serial sequence (2.2ms)   SELECT attr.attname, seq.relname
+ FROM pg_class seq,
+ pg_attribute attr,
+ pg_depend dep,
+ pg_namespace name,
+ pg_constraint cons
+ WHERE seq.oid = dep.objid
+ AND seq.relkind = 'S'
+ AND attr.attrelid = dep.refobjid
+ AND attr.attnum = dep.refobjsubid
+ AND attr.attrelid = cons.conrelid
+ AND attr.attnum = cons.conkey[1]
+ AND cons.contype = 'p'
+ AND dep.refobjid = '"articles"'::regclass
+
+  Reset sequence (181.0ms)   SELECT setval('"articles_id_seq"', (SELECT COALESCE(MAX("id")+(SELECT increment_by FROM "articles_id_seq"), (SELECT min_value FROM "articles_id_seq")) FROM "articles"), false)
+
+   (37.0ms)  COMMIT
+   (0.3ms)  ALTER TABLE "schema_migrations" ENABLE TRIGGER ALL;ALTER TABLE "people" ENABLE TRIGGER ALL;ALTER TABLE "articles" ENABLE TRIGGER ALL
+   (0.3ms)  ALTER TABLE "schema_migrations" DISABLE TRIGGER ALL;ALTER TABLE "people" DISABLE TRIGGER ALL;ALTER TABLE "articles" DISABLE TRIGGER ALL
+   (0.2ms)  BEGIN
+  Fixture Delete (0.4ms)  DELETE FROM "people"
+  Fixture Insert (13.9ms)  INSERT INTO "people" ("name", "email", "birth", "created_at", "updated_at", "id") VALUES ('Obi-Wan Kenobi', 'obi@sw.com', '3012-03-15', '2012-03-15 17:41:35', '2012-03-15 17:41:35', 632303495)
+  Fixture Insert (0.3ms)  INSERT INTO "people" ("name", "email", "birth", "created_at", "updated_at", "id") VALUES ('Luke Skywalker', 'luke@sw.com', '3052-03-15', '2012-03-15 17:41:35', '2012-03-15 17:41:35', 962534057)
+  Fixture Insert (0.3ms)  INSERT INTO "people" ("name", "email", "birth", "created_at", "updated_at", "id") VALUES ('Anakin Skywalker', 'anakin@sw.com', '3032-03-15', '2012-03-15 17:41:35', '2012-03-15 17:41:35', 222665832)
+  PK and serial sequence (2.1ms)   SELECT attr.attname, seq.relname
+ FROM pg_class seq,
+ pg_attribute attr,
+ pg_depend dep,
+ pg_namespace name,
+ pg_constraint cons
+ WHERE seq.oid = dep.objid
+ AND seq.relkind = 'S'
+ AND attr.attrelid = dep.refobjid
+ AND attr.attnum = dep.refobjsubid
+ AND attr.attrelid = cons.conrelid
+ AND attr.attnum = cons.conkey[1]
+ AND cons.contype = 'p'
+ AND dep.refobjid = '"people"'::regclass
+
+  Reset sequence (12.5ms)   SELECT setval('"people_id_seq"', (SELECT COALESCE(MAX("id")+(SELECT increment_by FROM "people_id_seq"), (SELECT min_value FROM "people_id_seq")) FROM "people"), false)
+
+   (15.0ms)  COMMIT
+   (0.2ms)  ALTER TABLE "schema_migrations" ENABLE TRIGGER ALL;ALTER TABLE "people" ENABLE TRIGGER ALL;ALTER TABLE "articles" ENABLE TRIGGER ALL
+   (0.9ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" 
+   (0.2ms)  SET search_path TO public
+   (537.3ms)  DROP DATABASE IF EXISTS "dummy_test"
+   (0.2ms)  SET search_path TO public
+   (2217.0ms)  CREATE DATABASE "dummy_test" ENCODING = 'unicode'
+   (176.4ms)  CREATE TABLE "articles" ("id" serial primary key, "name" character varying(255), "code" integer, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (153.9ms)  CREATE TABLE "people" ("id" serial primary key, "name" character varying(255), "email" character varying(255), "birth" date, "created_at" timestamp NOT NULL, "updated_at" timestamp NOT NULL) 
+   (10.3ms)  CREATE TABLE "schema_migrations" ("version" character varying(255) NOT NULL) 
+   (3.1ms)   SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
+ FROM pg_class t
+ INNER JOIN pg_index d ON t.oid = d.indrelid
+ INNER JOIN pg_class i ON d.indexrelid = i.oid
+ WHERE i.relkind = 'i'
+ AND d.indisprimary = 'f'
+ AND t.relname = 'schema_migrations'
+ AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+ ORDER BY i.relname
+
+   (85.1ms)  CREATE UNIQUE INDEX "unique_schema_migrations" ON "schema_migrations" ("version")
+   (0.5ms)  SELECT version FROM "schema_migrations"
+   (9.3ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120312175442')
+   (10.8ms)  INSERT INTO "schema_migrations" (version) VALUES ('20120312175303')