action_blocks 0.1.0

data/lib/action_blocks/data_engine/filter_engine.rb

@@ -0,0 +1,88 @@
+module ActionBlocks
+  # Data Engine
+  class FilterEngine
+    attr_accessor :tables, :root_klass, :root_key, :froms, :joins, :wheres,
+                  :selects, :joins, :filter_reqs
+
+    def initialize(root_klass, user: nil, filter_reqs: [])
+      @root_klass = root_klass
+      @filter_reqs = filter_reqs
+      @tables = {}
+      @joins = {}
+      @wheres = []
+      @froms = []
+    end
+
+    def process
+      @root_table = @root_klass.arel_table
+      @root_key = @root_klass.to_s.underscore.to_sym
+
+      # Add base table to tables
+      @tables[@root_key.to_sym] = @root_table
+
+      [@filter_reqs].flatten.each do |matchreq|
+        node, *rest = matchreq[:path1]
+        # puts "base node: #{node} rest #{rest}"
+        base_expression = walk_filter_path(@root_klass, node, @root_key, rest)
+
+        node, *rest = matchreq[:path2]
+        # puts "related node: #{node} rest #{rest}"
+        related_expression = walk_filter_path(@root_klass, node, @root_key, rest)
+
+        if base_expression.class.ancestors.include?(Arel::Attributes::Attribute)
+          where = base_expression.send(matchreq[:predicate], related_expression)
+        else
+          where = related_expression.send(matchreq[:predicate], base_expression)
+        end
+        @wheres << where
+
+      end
+
+    end
+
+    def walk_filter_path(klass, node, parent_key, col_path)
+      key = [parent_key, node].compact.join('_').to_sym
+      if node.class != Symbol
+        return node
+      end
+      if !col_path.empty?
+        # Create Arel Table Alias
+        relation = klass.reflections[node.to_s]
+        klass = relation.klass
+        @tables[key] = klass.arel_table.alias(key) unless @tables[key]
+        # Create Join
+        fk = relation.join_foreign_key
+        pk = relation.join_primary_key
+        join_on = @tables[key].create_on(@tables[parent_key][fk].eq(@tables[key][pk]))
+        @joins[key] = @tables[parent_key].create_join(@tables[key], join_on, Arel::Nodes::OuterJoin)
+        # Recurse
+        next_node, *rest = col_path
+        return walk_filter_path(klass, next_node, key, rest)
+      else
+        # Return expression
+        # puts "parent_key: #{node.to_sym}"
+        # puts "node: #{node.to_sym}"
+        return @tables[parent_key][node.to_sym]
+      end
+    end
+
+    def froms
+      []
+    end
+
+    def ordered_joins
+      @joins.values
+    end
+
+    def wheres
+      @wheres.reduce(&:and)
+    end
+
+    def query
+      @root_klass
+        .from(froms)
+        .joins(ordered_joins)
+        .where(wheres)
+    end
+  end
+end

data/lib/action_blocks/data_engine/selections_via_where_engine.rb

@@ -0,0 +1,134 @@
+module ActionBlocks
+  # Data Engine
+  class SelectionsViaWhereEngine
+    attr_accessor :tables, :root_klass, :selection_match_reqs, :selects, :joins, :selection_filter_reqs
+
+    def initialize(root_klass, user: nil, table_alias_prefix: nil, type: :many_to_many, selection_filter_reqs: [], selection_match_reqs: [], additional_where: nil)
+      @root_klass = root_klass
+      @table_alias_prefix = table_alias_prefix
+      @tables = {}
+      @joins = {}
+      @wheres = []
+      @froms = []
+      @type = type
+
+      @additional_where = additional_where
+
+      # I named them selection_match_reqs because
+      # the DataEngine may work with match_reqs in
+      # different contexts.  It may use them for
+      # summary fields or it may use them for
+      # a filtering a query to the children of some
+      # base models 'children'
+      @selection_match_reqs = selection_match_reqs
+      @selection_filter_reqs = selection_filter_reqs
+    end
+
+    def process
+      @root_table = @root_klass.arel_table.alias([@table_alias_prefix, @root_klass.to_s.underscore.pluralize].compact.join('_'))
+      root_key = [@table_alias_prefix, @root_klass.to_s.underscore.pluralize].compact.join('_').to_sym
+
+      @froms << @root_table
+      # Add base table to tables
+      @tables[root_key.to_sym] = @root_table
+
+      [@selection_match_reqs, @selection_filter_reqs].flatten.compact.each do |matchreq|
+        node, *rest = matchreq[:base_path]
+        # puts "base node: #{node} rest #{rest}"
+        base_expression = walk_selection_match_path(@root_klass, node, root_key, rest)
+
+        node, *rest = matchreq[:related_path]
+        # puts "related node: #{node} rest #{rest}"
+        related_expression = walk_selection_match_path(@root_klass, node, root_key, rest)
+
+        where = if base_expression.class.ancestors.include?(Arel::Attributes::Attribute)
+                  base_expression.send(matchreq[:predicate], related_expression)
+                else
+                  related_expression.send(matchreq[:predicate], base_expression)
+                end
+        @wheres << where
+      end
+    end
+
+    def walk_selection_match_path(klass, node, parent_key, col_path)
+      # puts "klass: #{klass} node: #{node} parent_key #{parent_key.inspect} col_path #{col_path.inspect}"
+      # pp [key, rest_col_path]
+      key = if node.class == Class
+              [@table_alias_prefix, node.to_s.underscore.pluralize].compact.join('_').to_sym
+            else
+              [@table_alias_prefix, parent_key, node].compact.join('_').to_sym
+            end
+      return node if node.class != Symbol && node.class != Class
+      if !col_path.empty?
+        # Create Arel Table Alias
+        if node.class != Class
+          relation = klass.reflections[node.to_s]
+          klass = relation.klass
+          @tables[key] = klass.arel_table.alias(key) unless @tables[key]
+          # Create Join
+          fk = relation.join_foreign_key
+          pk = relation.join_primary_key
+          join_on = @tables[key].create_on(@tables[parent_key][fk].eq(@tables[key][pk]))
+          @joins[key] = @tables[parent_key].create_join(@tables[key], join_on, Arel::Nodes::OuterJoin)
+        else
+          klass = node
+          unless @tables[key]
+            @tables[key] = klass.arel_table.alias(key) unless @tables[key]
+            @froms << @tables[key]
+          end
+        end
+        # Recurse
+        next_node, *rest = col_path
+        return walk_selection_match_path(klass, next_node, key, rest)
+      else
+        # Return expression
+        # puts "parent_key: #{node.to_sym}"
+        # puts "node: #{node.to_sym}"
+        return @tables[parent_key][node.to_sym]
+      end
+    end
+
+
+    def froms
+      if @type == :many_to_many
+        [@root_table]
+      else
+        @froms
+      end
+    end
+
+    def ordered_joins
+      if @type == :many_to_many
+        []
+      else
+        @joins.values
+      end
+    end
+
+    def wheres
+      @wheres << @additional_where if @additional_where
+      if @type == :many_to_many && (!@selection_match_reqs.empty? || !@selection_filter_reqs.empty?)
+        subquery_arel = subquery_for_many_to_many_selections.arel
+        # w = Arel::Nodes::In.new(@root_table[:id], subquery.ast)
+        @root_table[:id].in(subquery_arel)
+      else
+        @wheres.reduce(&:and)
+      end
+    end
+
+    def subquery_for_many_to_many_selections
+      # Arel::Distinct.new(@rook_klasas[:id])
+      @root_klass
+        .from([@froms].flatten)
+        .select(@root_table[:id])
+        .joins(@joins.values)
+        .where(@wheres.reduce(&:and))
+    end
+
+    def query
+      @root_klass
+       .joins(ordered_joins)
+        .where(wheres)
+    end
+  end
+end

data/lib/action_blocks/data_engine/summary_engine.rb

@@ -0,0 +1,72 @@
+module ActionBlocks
+  # Data Engine
+  class SummaryEngine
+    attr_accessor :tables, :root_klass, :summary_reqs, :selects, :joins
+
+    def initialize(root_klass, user: nil, summary_reqs: [])
+      @root_klass = root_klass
+      @tables = {}
+
+      @user = user
+
+      @selects = []
+
+      @summary_reqs = summary_reqs
+    end
+
+    def process
+      root_table = @root_klass.arel_table.alias(@root_klass.to_s.underscore.pluralize)
+      sub_table = @root_klass.arel_table.alias(['sub', @root_klass.to_s.underscore.pluralize].join('_'))
+
+      @summary_reqs.each do |summaryreq|
+        select_reqs = [summaryreq[:select_req]]
+        match_reqs = summaryreq[:match_reqs]
+        filter_reqs = summaryreq[:filter_reqs]
+
+        @fields_engine = ActionBlocks.config[:fields_engine].new(
+          summaryreq[:root_klass],
+          table_alias_prefix: 'sub',
+          select_reqs: select_reqs
+        )
+
+        # @selections_engine = SelectionsViaJoinsEngine.new(
+        @selections_engine = ActionBlocks.config[:selections_engine].new(
+          summaryreq[:root_klass],
+          table_alias_prefix: 'sub',
+          selection_match_reqs: match_reqs,
+          selection_filter_reqs: filter_reqs,
+          additional_where: root_table[:id].eq(sub_table[:id])
+        )
+
+        @fields_engine.process
+        @selections_engine.process
+
+        if ActionBlocks.config[:should_authorize]
+          @authorization_adapter = AuthorizationAdapter.new(engine: @fields_engine, user: @user)
+          @authorization_adapter.process
+        end
+
+        sub_query = summaryreq[:root_klass]
+                    .from([
+                      @fields_engine.froms,
+                      @selections_engine.froms,
+                    ].flatten.uniq)
+                    .select(@fields_engine.selects)
+                    .joins([
+                      @selections_engine.ordered_joins,
+                      @fields_engine.ordered_joins
+                    ].flatten.compact)
+                    .where([@selections_engine.wheres, @fields_engine.wheres].flatten.compact.reduce(&:and))
+                    .as(summaryreq[:select_req][:field_name].to_s)
+
+        @selects << sub_query
+      end
+
+    end
+
+    def query
+      @root_klass
+        .select(@selects)
+    end
+  end
+end

data/lib/action_blocks/engine.rb

@@ -0,0 +1,5 @@
+module ActionBlocks
+  class Engine < ::Rails::Engine
+    isolate_namespace ActionBlocks
+  end
+end

data/lib/action_blocks/error.rb

@@ -0,0 +1,62 @@
+module ActionBlocks
+  # Exception class to raise when there is an authorized access
+  # exception thrown. The exception has a few goodies that may
+  # be useful for capturing / recognizing security issues.
+  class AccessDenied < StandardError
+    attr_reader :user, :action, :subject
+
+    def initialize(user, action, subject = nil)
+      @user, @action, @subject = user, action, subject
+
+      super()
+    end
+
+    def message
+      I18n.t("action_block.access_denied.message")
+    end
+  end
+
+  class Error < RuntimeError
+  end
+
+  class ErrorLoading < Error
+    # Locates the most recent file and line from the caught exception's backtrace.
+    def find_cause(folder, backtrace)
+      backtrace.grep(/\/(#{folder}\/.*\.rb):(\d+)/){ [$1, $2] }.first
+    end
+  end
+
+  class DatabaseHitDuringLoad < ErrorLoading
+    def initialize(exception)
+      file, line = find_cause(:app, exception.backtrace)
+
+      super "Your file, #{file} (line #{line}), caused a database error while Active Block was loading. This " +
+            "is most common when your database is missing or doesn't have the latest migrations applied. To " +
+            "prevent this error, move the code to a place where it will only be run when a page is rendered. " +
+            "One solution can be, to wrap the query in a Proc. " +
+            "Original error message: #{exception.message}"
+    end
+
+    def self.capture
+      yield
+    rescue *database_error_classes => exception
+      raise new exception
+    end
+
+    private
+
+    def self.database_error_classes
+      @classes ||= []
+    end
+  end
+
+  class DependencyError < ErrorLoading
+  end
+
+  class NoMenuError < KeyError
+  end
+
+  class GeneratorError < Error
+  end
+
+end

data/lib/action_blocks/generator_helper.rb

@@ -0,0 +1,134 @@
+module ActionBlocks
+  module GeneratorHelper
+    protected
+
+    def variable(cname=nil)
+      cn = cname || class_name
+      variableize(cn)
+    end
+
+    def collection_name(cname=nil)
+      cn = cname || class_name
+      collectionize(cn)
+    end
+
+    def collectionize(s)
+      s.to_s.underscore.pluralize
+    end
+
+    def variableize(s)
+      s.to_s.underscore.singularize
+    end
+
+    def has_many_associations?(cname=nil)
+      cn = cname || class_name
+      cn.constantize.reflect_on_all_associations(:has_many).map(&:name).length > 0
+    end
+
+    def has_many_associations(cname=nil)
+      cn = cname || class_name
+      cn.constantize.reflect_on_all_associations(:has_many).map(&:name).select {|hm| hm.downcase != 'versions'}
+    end
+
+    def has_many_association_details(cname=nil)
+      cn = cname || class_name
+      cn.constantize.reflect_on_all_associations(:has_many).select {|hm| hm.name.downcase != 'versions'}
+    end
+
+    def has_one_associations(cname=nil)
+      cn = cname || class_name
+      cn.constantize.reflect_on_all_associations(:has_one).map(&:name)
+    end
+
+    def has_one_association_details(cname=nil)
+      cn = cname || class_name
+      cn.constantize.reflect_on_all_associations(:has_one)
+    end
+
+    def belongs_to_associations(cname=nil)
+      if respond_to?(:attributes) && attributes.present?
+        attributes.select{|a| a.reference?}.map(&:name)
+      else
+        cn = cname || class_name
+        begin
+          cn.constantize.reflect_on_all_associations(:belongs_to).map(&:name)
+        rescue
+          []
+        end
+      end
+    end
+
+    def belongs_to_association_details(cname=nil)
+      if respond_to?(:attributes) && attributes.present?
+        attributes.select{|a| a.reference?}
+      else
+        cn = cname || class_name
+        begin
+          cn.constantize.reflect_on_all_associations(:belongs_to)
+        rescue
+          []
+        end
+      end
+    end
+
+    def content_columns(cname=nil)
+      if respond_to?(:attributes) && attributes.present?
+        cols = attributes.reject{|a| a.reference?}.map(&:name).map{|n| clean(n)}.compact
+        cols
+      else
+        cn = cname || class_name
+        begin
+          cols = cn.constantize.content_columns.map(&:name).map {|c| clean(c)}.compact
+          cols
+        rescue => ex
+          puts ex.message
+          []
+        end
+      end
+    end
+
+    def content_column_details(cname=nil)
+      if respond_to?(:attributes) && attributes.present?
+        attributes.reject{|a| a.reference?}
+      else
+        cn = cname || class_name
+        begin
+          cn.constantize.content_columns
+        rescue
+          []
+        end
+      end
+    end
+
+    def clean(c)
+      c = c.to_s
+      return nil if c.in?(%w(updated_at created_at deleted deleted_at)) || c =~ /_file_size|_updated_at|_content_type/
+      c.to_s.gsub('_file_name','')
+    end
+
+    def attachment_names(cname=nil)
+      if respond_to?(:attributes) && attributes.present?
+        attributes.select{|a| a.attachment?}.map(&:name)
+      else
+        cn = cname || class_name
+        names = cn.constantize.content_columns.select{|a| a.name.to_s =~ /_file_name\Z/}.map{|a| a.name.to_s.gsub(/_file_name\Z/, "")}
+        names
+      end
+    end
+
+    def association_class_exists_with_this_name?(association_name)
+      klass = Module.const_get(association_name.to_s.singularize.classify)
+      return klass.is_a?(Class)
+    rescue NameError
+      return false
+    end
+
+    def field_content_columns
+      if options.fields && options.fields.length > 0
+        return options.fields & content_columns
+      else
+        return content_columns
+      end
+    end
+  end
+end