post_json 1.0.3

data/lib/post_json/concerns/query_methods.rb

@@ -0,0 +1,157 @@
+module PostJson
+  module QueryMethods
+    extend ActiveSupport::Concern
+
+    #
+    # Use 'query_tree' to integrate with this module
+    #
+
+    include ArgumentMethods
+
+    def query_tree
+      @query_tree ||= {}
+    end
+
+    def query_tree_renew!
+      @query_tree = @query_tree.deep_dup
+    end
+
+    def query_clone
+      cloned_self = clone
+      cloned_self.query_tree_renew!
+      cloned_self
+    end
+
+    def add_query(method, *arguments)
+      query_tree[method] = (query_tree[method] || []) + arguments
+      self
+    end
+
+    def except!(*attributes)
+      remove_keys = flatten_arguments(attributes).map(&:to_sym)
+      query_tree.except!(*remove_keys)
+      self
+    end
+
+    def except(*attributes)
+      query_clone.except!(*attributes)
+    end
+
+    def limit!(value)
+      except!(:limit).add_query(:limit, value.to_i)
+    end
+
+    def limit(value)
+      query_clone.limit!(value)
+    end
+
+    def offset!(value)
+      except!(:offset).add_query(:offset, value.to_i)
+    end
+
+    def offset(value)
+      query_clone.offset!(value)
+    end
+
+    def page!(page, per_page)
+      page_int = page.to_i
+      per_page_int = per_page.to_i
+      offset!((page_int-1)*per_page_int).limit!(per_page_int)
+    end
+
+    def page(page, per_page)
+      query_clone.page!(page, per_page)
+    end
+
+    def only!(*attributes)
+      keep_keys = flatten_arguments(attributes).map(&:to_sym)
+      query_tree.keep_if{|key| key.in?(keep_keys)}
+      self
+    end
+
+    def only(*attributes)
+      query_clone.only!(*attributes)
+    end
+
+    def order!(*args)
+      if 0 < args.length
+        flatten_arguments(args).each do |arg|
+          name, direction = arg.split(' ')
+
+          direction = direction.to_s.upcase
+          direction = "ASC" unless direction.present?
+
+
+          if direction.in?(["ASC", "DESC"]) == false
+            raise ArgumentError, "Direction should be 'asc' or 'desc'"
+          end
+
+          add_query(:order, "#{name} #{direction}")
+        end
+      end
+      self
+    end
+
+    def order(*args)
+      query_clone.order!(*args)
+    end
+
+    def reorder!(*args)
+      except!(:order).order!(*args)
+    end
+
+    def reorder(*args)
+      query_clone.reorder!(*args)
+    end
+
+    def reverse_order!
+      current_order = query_tree.delete(:order)
+      if current_order.present?
+        current_order.each do |arg|
+          name, direction = arg.split(' ')
+          reverse_direction = direction == "DESC" ? "ASC" : "DESC"
+          order!("#{name} #{reverse_direction}")          
+        end
+        self
+      else
+        order!("id DESC")
+      end
+    end
+
+    alias_method :reverse!, :reverse_order!
+
+    def reverse_order
+      query_clone.reverse_order!
+    end
+
+    alias_method :reverse, :reverse_order
+
+    def where!(opts = :chain, *rest)
+      if opts == :chain || opts.blank?
+        self
+      else
+        case opts
+        when String
+          if opts.start_with?("function")
+            add_query(:where_function, {function: opts, arguments: rest})
+          else
+            add_query(:where_forward, [opts] + rest)
+          end
+        when Array
+          add_query(:where_forward, [opts] + rest)
+        when Hash
+          opts.stringify_keys.flatten_hash.each do |attribute, value|
+            add_query(:where_equal, {attribute: attribute, argument: value})
+          end
+        else
+          add_query(:where_forward, [opts] + rest)
+        end
+        self
+      end
+    end
+
+    def where(filter = :none, *options)
+      query_clone.where!(filter, *options)
+    end
+  end
+end

data/lib/post_json/concerns/settings_methods.rb

@@ -0,0 +1,106 @@
+module PostJson
+  module SettingsMethods
+    extend ActiveSupport::Concern
+
+    def __model__settings
+      @__model__settings ||= self.class.find_settings_or_create
+    end
+
+    module ClassMethods
+      def find_settings
+        ModelSettings.by_collection(collection_name).first
+      end
+
+      def find_settings_or_create
+        ModelSettings.by_collection(collection_name).first_or_create(collection_name: collection_name)
+      end
+
+      def find_settings_or_initialize
+        ModelSettings.by_collection(collection_name).first_or_initialize(collection_name: collection_name)
+      end
+
+      def read_settings_attribute(attribute_name)
+        attribute_name = attribute_name.to_s
+        settings = find_settings_or_initialize
+        settings[attribute_name]
+      end
+
+      def write_settings_attribute(attribute_name, value)
+        attribute_name = attribute_name.to_s
+        settings = find_settings_or_initialize
+        if settings[attribute_name] != value
+          settings[attribute_name] = value 
+          settings.save! 
+        end
+        value
+      end
+
+      def meta
+        HashWithIndifferentAccess.new(read_settings_attribute('meta'))
+      end
+
+      def meta=(hash)
+        write_settings_attribute('meta', HashWithIndifferentAccess.new(hash))
+      end
+
+      def use_timestamps
+        read_settings_attribute('use_timestamps')
+      end
+
+      def use_timestamps=(value)
+        write_settings_attribute('use_timestamps', value)
+      end
+
+      alias_method :record_timestamps, :use_timestamps
+      alias_method :record_timestamps=, :use_timestamps=
+
+      def created_at_attribute_name
+        read_settings_attribute('created_at_attribute_name')
+      end
+
+      def created_at_attribute_name=(attribute_name)
+        write_settings_attribute('created_at_attribute_name', attribute_name)
+      end
+
+      def updated_at_attribute_name
+        read_settings_attribute('updated_at_attribute_name')
+      end
+
+      def updated_at_attribute_name=(attribute_name)
+        write_settings_attribute('updated_at_attribute_name', attribute_name)
+      end
+
+      def include_version_number
+        read_settings_attribute('include_version_number')
+      end
+
+      def include_version_number=(value)
+        write_settings_attribute('include_version_number', value)
+      end
+
+      def version_attribute_name
+        read_settings_attribute('version_attribute_name')
+      end
+
+      def version_attribute_name=(attribute_name)
+        write_settings_attribute('version_attribute_name', attribute_name)
+      end
+
+      def use_dynamic_index
+        read_settings_attribute('use_dynamic_index')
+      end
+
+      def use_dynamic_index=(value)
+        write_settings_attribute('use_dynamic_index', value)
+      end
+
+      def create_dynamic_index_milliseconds_threshold
+        read_settings_attribute('create_dynamic_index_milliseconds_threshold')
+      end
+
+      def create_dynamic_index_milliseconds_threshold=(millisecs)
+        write_settings_attribute('create_dynamic_index_milliseconds_threshold', millisecs)
+      end
+    end
+  end
+end

data/lib/post_json/dynamic_index.rb

@@ -0,0 +1,99 @@
+module PostJson
+  class DynamicIndex < ActiveRecord::Base
+    class << self
+      include ArgumentMethods
+
+      def ensure_index(model_settings_id, *selectors)
+        selectors = flatten_arguments(selectors)
+        if selectors.length == 0
+          []
+        else
+          existing_selectors = where(model_settings_id: model_settings_id).pluck(:selector)
+          new_selectors = selectors - existing_selectors
+          new_selectors.map do |selector|
+            create(model_settings_id: model_settings_id, selector: selector)
+          end
+        end
+      end
+
+      def indexed_selectors(model_settings_id)
+        # distinct is needed since race condition can cause 1+ records to own the same index
+        where(model_settings_id: model_settings_id).distinct.pluck(:selector)
+      end
+
+      def destroy_index(model_settings_id, selector)
+        where(model_settings_id: model_settings_id, selector: selector).destroy_all.present?
+      end
+    end
+
+    self.table_name = "post_json_dynamic_indexes"
+
+    belongs_to :model_settings
+
+    attr_readonly :selector
+
+    validates :selector,    presence: true
+
+    def index_name
+      # if defined?(@index_name)
+      #   @index_name
+      # else
+      #   prefix = "dyn_#{model_settings_id.gsub('-', '')}_"
+      #   @index_name = if 63 < prefix.length + selector.length
+      #                   digest = Digest::MD5.hexdigest(selector) 
+      #                   "#{prefix}#{digest}"[0..62]
+      #                 else
+      #                   "#{prefix}#{selector.gsub('.', '_')}"
+      #                 end
+      # end
+
+      @index_name ||= unless @index_name
+                        prefix = "dyn_#{model_settings_id.gsub('-', '')}_"
+                        if 63 < prefix.length + selector.length
+                          digest = Digest::MD5.hexdigest(selector) 
+                          "#{prefix}#{digest}"[0..62]
+                        else
+                          "#{prefix}#{selector.gsub('.', '_')}"
+                        end
+                      end
+    end
+
+    after_create do |dynamic_index|
+      begin
+        ActiveRecord::Base.connection.execute(dynamic_index.inline_create_index_procedure)
+      rescue ActiveRecord::StatementInvalid => e
+        # lets ignore this exception if the index already exists. this could happen in a rare race condition.
+        orig = e.original_exception
+        raise unless orig.is_a?(PG::DuplicateTable) && orig.message.include?("already exists")
+      end
+    end
+
+    after_destroy do |dynamic_index|
+      ActiveRecord::Base.connection.execute("DROP INDEX IF EXISTS #{dynamic_index.index_name};")
+    end
+
+    def inline_create_index_procedure
+      schemas = ActiveRecord::Base.connection.schema_search_path.gsub(/\s+/, '').split(',')
+      current_schema =  if schemas[0] == "\"$user\"" && 1 < schemas.length
+                          schemas[1]
+                        else
+                          schemas[0]
+                        end
+"DO $$
+BEGIN
+
+IF NOT EXISTS (
+    SELECT 1
+    FROM   pg_class c
+    JOIN   pg_namespace n ON n.oid = c.relnamespace
+    WHERE  c.relname = '#{index_name}'
+    AND    n.nspname = '#{current_schema}' -- 'public' by default
+    ) THEN
+
+    CREATE INDEX #{index_name} ON #{current_schema}.#{Base.table_name} (json_selector('#{selector}', __doc__body)) WHERE __doc__model_settings_id = '#{model_settings_id.gsub('-', '')}';
+END IF;
+
+END$$;"
+    end
+  end
+end

data/lib/post_json/model_settings.rb

@@ -0,0 +1,17 @@
+module PostJson
+  class ModelSettings < ActiveRecord::Base
+    self.table_name = "post_json_model_settings"
+
+    before_validation do |settings|
+      settings.collection_name = settings.collection_name.to_s.strip
+    end
+
+    scope :by_collection, ->(name) { where("lower(collection_name) = ?", name.to_s.strip.downcase) }
+
+    class << self
+      def collection_name_digest(name)
+        Digest::MD5.hexdigest(name.to_s.strip.downcase)
+      end
+    end
+  end
+end

data/lib/post_json/query_translator.rb

@@ -0,0 +1,48 @@
+module PostJson
+  class QueryTranslator
+
+    include FinderMethods
+
+    def initialize(relation)
+      @relation = relation
+    end
+
+    def model_class
+      @relation.klass
+    end
+
+    def table_name
+      model_class.table_name
+    end
+
+    def each(&block)
+      relation_query.each(&block)
+    end
+
+    def execute(ignore_dynamic_indexes = false, &block)
+      if ignore_dynamic_indexes == true || model_class.use_dynamic_index != true
+        block.call(relation_query)
+      else
+        result = block.call(relation_query)
+        select_query = ActiveRecord::Base.connection.last_select_query
+        select_duration = ActiveRecord::Base.connection.last_select_query_duration * 1000
+        if model_class.use_dynamic_index == true &&
+           model_class.create_dynamic_index_milliseconds_threshold < select_duration
+          selectors = select_query.scan(/.*?json_selector\('(.*?)', __doc__body\)/).flatten.uniq
+          model_class.create_dynamic_indexes(selectors)
+        end
+        result
+      end
+    end
+
+    def relation_query
+      active_record_send_invocations.inject(@relation) do |query, send_arguments|
+        query.send(*send_arguments)
+      end
+    end
+
+    def create(attributes = {})
+      relation_query.create(attributes.with_indifferent_access)
+    end
+  end
+end

data/lib/post_json/version.rb

@@ -0,0 +1,3 @@
+module PostJson
+  VERSION = "1.0.3"
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .