action_blocks 0.1.0

data/lib/action_blocks.rb

@@ -0,0 +1,76 @@
+require "action_blocks/engine"
+require "action_blocks/version"
+require 'action_block_loader'
+
+module ActionBlocks
+
+  autoload :AuthorizationBuilder, 'action_blocks/builders/authorization_builder'
+  autoload :BarchartBuilder, 'action_blocks/builders/barchart_builder'
+  autoload :BaseBuilder, 'action_blocks/builders/base_builder'
+  autoload :BlockType, 'action_blocks/builders/block_type'
+  autoload :FormBuilder, 'action_blocks/builders/form_builder'
+  autoload :LayoutBuilder, 'action_blocks/builders/layout_builder'
+  autoload :ModelBuilder, 'action_blocks/builders/model_builder'
+  autoload :SummaryFieldAggregationFunctions, 'action_blocks/builders/summary_field_aggregation_functions'
+  autoload :TableBuilder, 'action_blocks/builders/table_builder'
+  autoload :WorkspaceBuilder, 'action_blocks/builders/workspace_builder'
+
+  # autoload :AuthorizationEngine, 'action_blocks/data_engine/authorization_engine'
+  autoload :AuthorizationAdapter, 'action_blocks/data_engine/authorization_adapter'
+  autoload :FilterAdapter, 'action_blocks/data_engine/filter_adapter'
+
+  autoload :DatabaseFunctions, 'action_blocks/data_engine/database_functions'
+  autoload :DataEngine, 'action_blocks/data_engine/data_engine'
+  autoload :FieldsEngine, 'action_blocks/data_engine/fields_engine'
+  autoload :FilterEngine, 'action_blocks/data_engine/filter_engine'
+  autoload :SelectionsViaWhereEngine, 'action_blocks/data_engine/selections_via_where_engine'
+  autoload :SummaryEngine, 'action_blocks/data_engine/summary_engine'
+
+  # autoload :BlocksController, 'action_blocks/app/controllers/action_blocks/blocks_controller'
+
+  autoload :Store, 'action_blocks/store'
+
+  class << self
+    attr_accessor :block_db, :loader, :selections_engine, :config
+  end
+
+  @config = {
+    fields_engine: FieldsEngine,
+    selections_engine: SelectionsViaWhereEngine,
+    filter_engine: FilterEngine,
+    summary_engine: SummaryEngine,
+    should_authorize: true,
+    authorization_adapter: AuthorizationAdapter
+  }
+
+  def self.block_store
+    self.block_db ||= ActionBlocks::Store.new
+    return self.block_db
+  end
+
+  def self.initial_load
+    Rails.application.config.after_initialize do
+      self.load
+    end
+  end
+
+
+  def self.load
+    self.loader = ActionBlocks::Loader.new('app/blocks')
+    self.loader.load!
+    self.block_store.after_load
+    self.loader.attach_reloader
+    self.block_store.freeze_builders
+  end
+
+  def self.unload
+    self.block_db = nil
+  end
+
+  def self.method_missing(m, *args, &block)
+    self.block_store.send(m, *args, &block)
+  end
+
+end
+
+ require 'action_blocks/error'

data/lib/action_blocks/builders/authorization_builder.rb

@@ -0,0 +1,21 @@
+module ActionBlocks
+    class AuthorizationBuilder < ActionBlocks::BlockType
+        block_type :authorization
+        sets :active_model
+        builds_many :rls, :grant, 'ActionBlocks::RlsBuilder'
+        includes_scheme_helpers
+    end
+
+    class RlsBuilder < ActionBlocks::BlockType
+        block_type :rls
+        sets :role
+        sets :filter
+        sets :scheme # Lisp like data structure sp
+
+        def before_build(parent, role, scheme=nil)
+            @role = role
+            @id = "#{parent.id}-#{role}"
+            @scheme = scheme
+        end
+    end
+end

data/lib/action_blocks/builders/barchart_builder.rb

@@ -0,0 +1,48 @@
+module ActionBlocks
+
+  class BarchartBuilder < ActionBlocks::BlockType
+    block_type :barchart
+    sets :title
+    sets :scope
+    sets :calculate
+    builds :group, 'ActionBlocks::BarchartGroupBuilder'
+    builds :subgroup, 'ActionBlocks::BarchartGroupBuilder'
+
+    def before_build(parent, *args)
+      @id = "#{parent.id}_#{args.first}"
+      @title = id.to_s.titleize
+      @calculate = :count
+    end
+
+    def hashify(user)
+      {
+        title: @title,
+        key: key,
+        type: type,
+        group: @group.try(:hashify, user),
+        subgroup: @subgroup.try(:hashify, user)
+      }
+    end
+  end
+
+  class BarchartGroupBuilder < ActionBlocks::BaseBuilder
+    sets :column
+    sets :order_by
+    sets :grouping_by
+
+    def before_build(parent, *args)
+      @column = args[0]
+      @order_by = :ascending
+      @grouping_by = :equal_values
+    end
+
+    def hashify(user)
+      {
+        column: @column,
+        order_by: @order_by,
+        grouping_by: @grouping_by
+      }
+    end
+  end
+
+end

data/lib/action_blocks/builders/base_builder.rb

@@ -0,0 +1,221 @@
+module ActionBlocks
+  class BaseBuilder
+    include ActiveModel::Validations
+    attr_accessor :id, :dsl_delegate
+
+    def self.block_type(t)
+      self.define_method("type") do
+        return t
+      end
+    end
+
+    # Dynamically create class to delegate dsl methods to
+    @@delegate_classes = {}
+    @@array_fields = {}
+
+    def self.delegate_class()
+      key = self.to_s
+      if @@delegate_classes[key] == nil
+        @@delegate_classes[key] = Class.new() do
+          def initialize(obj)
+            @obj = obj
+          end
+        end
+      end
+      @@delegate_classes[key]
+    end
+
+    def self.array_fields()
+      key = self.to_s
+      if @@array_fields[key] == nil
+        @@array_fields[key] = []
+      end
+      @@array_fields[key]
+    end
+
+    def self.sets(field_name)
+      self.send(:attr_accessor, field_name)
+      self.delegate_class.define_method(field_name) do |value|
+        @obj.send("#{field_name}=", value)
+      end
+    end
+
+    def self.builds(field_name, klass)
+      self.send(:attr_accessor, field_name)
+      self.delegate_class.define_method(field_name) do |*p, &block|
+        dsl_class = eval(klass.to_s)
+        n = dsl_class.new()
+        n.id = p.first
+        n.before_build(@obj, *p)
+        if n.is_block?
+          ActionBlocks.store(n)
+        end
+        ActionBlocks.add_to_validator(n)
+        n.dsl_delegate.instance_eval(&block) if block!=nil
+        n.after_build(@obj, p.first)
+        @obj.send("#{field_name}=", n)
+      end
+    end
+
+    def self.sets_many(field_name, entry_method)
+      self.array_fields().append(field_name)
+      self.send(:attr_accessor, field_name)
+      self.delegate_class.define_method(entry_method) do |*p, &block|
+        @obj.send(field_name).append(p.first)
+      end
+    end
+
+    # references :name_field,  -> (s, obj) {"field-#{obj.id}-#{s}"}
+    # self.referendes block_type, [entry_method], [keyFn(f,Obj)]
+    def self.references(entry_method, block_type=nil, key_proc=nil, handler: nil)
+      block_type = block_type || entry_method
+      self.send(:attr_accessor, "#{entry_method}_key")
+
+      if handler
+        self.delegate_class.define_method(entry_method) do |*p|
+          handler.call(@obj, *p)
+        end
+      else
+        self.delegate_class.define_method(entry_method) do |*p|
+          reference_key = "#{entry_method}_key"
+          if key_proc
+            k = key_proc.call(p.first, @obj)
+          else
+            k = "#{block_type}-#{p.first}"
+          end
+          @obj.send("#{entry_method}_key=", k)
+        end
+      end
+
+      self.define_method(entry_method) do
+        k = send("#{entry_method}_key")
+        if k
+          return ActionBlocks.find(k)
+        else
+          return nil
+        end
+      end
+
+      self.validate "#{entry_method}_reference_is_valid".to_sym
+      self.define_method("#{entry_method}_reference_is_valid") do
+        reference_key = send("#{entry_method}_key")
+        if reference_key
+          if !ActionBlocks.find(reference_key)
+            errors.add(entry_method.to_sym, "Reference #{reference_key} doesn't match any block in store.")
+          end
+        end
+      end
+    end
+
+    def self.includes_scheme_helpers
+      self.delegate_class.define_method(:_and) do |*args|
+          return [:and, *args] 
+      end
+  
+      self.delegate_class.define_method(:_or) do |*args| 
+          return [:or, *args] 
+      end
+  
+      self.delegate_class.define_method(:_eq) do |left, right|
+          return [:eq, left, right] 
+      end
+      
+      self.delegate_class.define_method(:_user) do |field|
+          return [:user, field]
+      end
+  
+      self.delegate_class.define_method(:_not_eq) do |left, right|
+          return [:not_eq, left, right]
+      end  
+    end
+
+    def self.builds_many(field_name, entry_method, klass)
+      self.array_fields().append(field_name)
+      self.define_method("#{field_name}_hash") do
+        Hash[self.send(field_name).map do |x|
+          [x.id, x]
+        end]
+      end
+
+      self.send(:attr_accessor, field_name)
+      self.delegate_class.define_method(entry_method) do |*p, &block|
+        dsl_class = eval(klass.to_s)
+        n = dsl_class.new()
+        n.id = p.first
+        n.before_build(@obj, *p)
+        if n.is_block?
+          ActionBlocks.store(n)
+        end
+        ActionBlocks.add_to_validator(n)
+        n.dsl_delegate.instance_eval(&block) if block!=nil
+        n.after_build(@obj, p.first)
+        if @obj.send(field_name) == nil
+          @obj.send("#{field_name}=",[n])
+        else
+          @obj.send(field_name).append(n)
+        end
+      end
+    end
+
+
+    def initialize()
+      @dsl_delegate = self.class.delegate_class.new(self)
+      self.class.array_fields.each do |array_field|
+        self.send("#{array_field}=", [])
+      end
+    end
+
+    def key
+      if(is_block?)
+        "#{type}-#{@id}"
+      else
+        @id
+      end
+    end
+
+    def ui_reference()
+      key()
+    end
+
+    def evaluate(&block)
+      @dsl_delegate.instance_eval(&block)
+    end
+
+    def before_build(parent, *p)
+    end
+
+    def after_build(parent, *p)
+    end
+
+    def after_load()
+    end
+
+    def is_block?
+      false
+    end
+
+
+    # Valid the object when freeze is called so the object
+    def freeze
+      self.valid?
+      super
+    end
+
+    # Runs all the specified validations and returns true if no errors were added
+    # otherwise false. Context can optionally be supplied to define which callbacks
+    # to test against (the context is defined on the validations using :on).
+    def valid?(context = nil)
+      unless self.frozen?
+         current_context, self.validation_context = validation_context, context
+         errors.clear
+         @valid = run_validations!
+       else
+         @valid
+       end
+    ensure
+      self.validation_context = current_context unless self.frozen?
+    end
+
+  end
+
+end

data/lib/action_blocks/builders/block_type.rb

@@ -0,0 +1,11 @@
+module ActionBlocks
+  class BlockType < ActionBlocks::BaseBuilder
+    def is_block?
+      true
+    end
+
+    def type
+      raise "#{self.class} should specify its block_type."
+    end
+  end
+end

data/lib/action_blocks/builders/command_builder.rb

@@ -0,0 +1,6 @@
+module ActionBlocks
+
+  class CommandBuilder < ActionBlocks::BlockType
+    references :model
+  end
+end

data/lib/action_blocks/builders/form_builder.rb

@@ -0,0 +1,117 @@
+module ActionBlocks
+
+  class FormBuilder < ActionBlocks::BlockType
+    attr_accessor :form_fields, :model_id, :model_fields, :form_fields_hash, :model_fields_hash
+    block_type :form
+    references :model, handler: -> (form_builder, model_id) do
+      form_builder.model_key = "model-#{model_id}"
+      form_builder.model_id = model_id
+    end
+
+    builds_many :sections, :section, 'ActionBlocks::FormSectionBuilder'
+
+    def before_build(parent, *args)
+      @form_fields = []
+      @form_fields_hash = {}
+    end
+
+    def add_form_field(ff)
+      name = ff.id
+      @form_fields << ff
+      @form_fields_hash[name] = ff
+    end
+
+    def model_fields
+      @form_fields.map { |ff| ff.field }
+    end
+
+    def record_engine(user:, record_id:)
+      DataEngine.new(model.active_model,
+        filter_reqs: filter_reqs(user: user, record_id: record_id),
+        select_reqs: select_reqs(user: user)
+      )
+    end
+
+    def record_to_json(user:, record_id:)
+      record_engine(user: user, record_id: record_id).first_to_json
+    end
+
+    def select_reqs(user:)
+      srs = model_fields.map {|mf| mf.select_requirements }.flatten
+    end
+
+    def filter_reqs(user:, record_id:)
+      model.filter_reqs(user: user, record_id: record_id)
+    end
+
+    def hashify(user)
+      {
+        context: @context,
+        sections: @sections.map {|s| s.hashify(user)},
+        key: key,
+        type: type
+      }
+    end
+
+  end
+
+  # Section
+
+  class FormSectionBuilder < ActionBlocks::BaseBuilder
+    attr_accessor :form
+    sets :width
+    sets :title
+    builds_many :fields, :field, 'ActionBlocks::FormFieldBuilder'
+
+    def before_build(parent, *args)
+      @form = parent
+      @title = args[0].to_s.titleize
+      @width = 4
+      @label = @field.to_s.titleize
+    end
+
+    def hashify(user)
+      {
+        title: @title,
+        width: @width,
+        fields: @fields.map {|f| f.hashify(user)},
+      }
+    end
+  end
+
+  # Field
+
+  class FormFieldBuilder < ActionBlocks::BaseBuilder
+    attr_accessor :name, :form, :section
+    references :field
+    sets :width
+    sets :label
+    sets :label_above
+
+    def before_build(parent, *args)
+      @section = parent
+      @form = @section.form
+      @name = args[0]
+      @field_key = "field-#{@form.model_id}-#{@name}"
+      @width = parent.width
+      @label = @name.to_s.titleize
+      @label_above = false
+    end
+
+    def after_build(*args)
+      @form.add_form_field(self)
+    end
+
+    def hashify(user)
+      {
+        type: 'field',
+        field_key: @field_key,
+        label_above: @label_above,
+        label: @label,
+        width: @width,
+      }
+    end
+  end
+
+
+end