basepack 0.0.2

data/lib/basepack/delegation.rb

@@ -0,0 +1,66 @@
+module Basepack
+  module Delegation
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def delegate_attrs(*attrs_names)
+        options = attrs_names.last.is_a?(Hash) ? attrs_names.pop : {}
+        to = options[:to] || :delegate
+
+        attrs_names.each do |attr|
+          if attr[-1] == "?"
+            writter = attr[0...-1]
+            define_method attr do
+              send(writter)
+            end
+          else
+            writter = attr
+          end
+
+          var = "@#{writter}".to_sym
+          default = "#{writter}!".to_sym
+          delegated = "#{writter}_delegated".to_sym
+
+          attr_writer writter
+
+          define_method writter do |&block|
+            if block
+              instance_variable_set(block)
+            else
+              if instance_variable_defined?(var)
+                val = instance_variable_get(var)
+                val.is_a?(Proc) ? instance_eval(&val) : val
+              else
+                send(default)
+              end
+            end
+          end
+
+          define_method delegated do
+            d = send(to)
+            d.respond_to?(attr) ? d.public_send(attr) : nil
+          end
+
+          define_method default do
+            send(delegated)
+          end
+        end
+      end
+
+      def attr_default(attr, if_args = [], &block)
+        delegated = "#{attr}_delegated".to_sym
+        if_args = if_args.map {|a| "@#{a}".to_sym }
+
+        define_method "#{attr}!" do
+          val = send(delegated)
+          if val.nil? or if_args.any? {|a| instance_variable_defined?(a) }
+            instance_eval(&block)
+          else
+            val # no argument redefined, return delegate
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/basepack/engine.rb

@@ -0,0 +1,28 @@
+require 'csv'
+require 'rails_admin'
+require 'inherited_resources'
+require 'select2-rails'
+require 'bootstrap-modal-rails'
+require 'underscore-rails'
+require 'underscore-string-rails'
+require 'rails-i18n'
+
+module Basepack
+  class Engine < ::Rails::Engine
+    config.autoload_paths += [root.join('lib')]
+    #if Rails.env.development?
+    #  config.to_prepare do
+    #    Rails.logger.debug "RELOADING BASEPACK"
+    #    require_dependency Basepack::Engine.root.join('lib', 'basepack').to_s
+    #  end
+    #end
+
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+
+end

data/lib/basepack/filter_ql.rb

@@ -0,0 +1,267 @@
+# encoding: UTF-8
+require 'parslet'
+
+module Basepack
+  class FilterQL
+    class ParseError < StandardError; end
+
+    class Parser < Parslet::Parser
+      def stri(str)
+        key_chars = str.split(//)
+        key_chars.collect! { |char| match["#{char.upcase}#{char.downcase}"] }.reduce(:>>)
+      end
+
+      rule(:spaces)         { match('\s').repeat(1) } # at least 1 space character (space, tab, new line, carriage return)
+      rule(:spaces?)        { spaces.maybe } # a bunch of spaces or not
+
+      rule(:quote)          { str("'") }
+      rule(:nonquote)       { str("'").absnt? >> any }
+
+      rule(:dbquote)          { str('"') }
+      rule(:nondbquote)       { str('"').absnt? >> any }
+
+      rule(:escape)         { str('\\') >> any }
+      rule(:comma) { spaces? >> str(',') >> spaces? }
+
+      rule(:and_op)         { stri('and') >> spaces? }
+      rule(:or_op)          { stri('or') >> spaces? }
+      rule(:lparen)         { str("(") >> spaces? }
+      rule(:rparen)         { str(")") >> spaces? }
+      rule(:not_op)         { spaces? >> stri('not').maybe.as(:not) >> spaces? }
+
+      rule(:operator)       { str('=') | str('!=') | str('>=') | str('<=') | str('>') | str('<') }
+      rule(:str_op)         { stri('like') | stri('cont') | stri('start') | stri('end') }
+      rule(:switch_op)      { stri('null') | stri('blank') }
+      rule(:identifier)     { (match('[a-z_]') >> match('[a-z0-9_]').repeat).as(:identifier) }
+      rule(:string)         { (quote >> (escape | nonquote).repeat.as(:string) >> quote) | (dbquote >> (escape | nondbquote).repeat.as(:string) >> dbquote) }
+      rule(:integer)        { (str('+') | str('-')).maybe >> match('[0-9]').repeat(1) }
+      rule(:float)          { integer >> (str('.') >> match('[0-9]').repeat(1) | stri('e') >> match('[0-9]').repeat(1)) }
+      rule(:literal)        { string | array | jshash | function.as(:function) | float.as(:float) | integer.as(:integer) | stri('true').as(:true) | stri('false').as(:false) }
+
+      rule(:array)          { str('[') >> spaces? >> (literal >> (comma >> literal).repeat).maybe.as(:array) >> spaces? >> str(']') }
+      rule(:hash_pair)      { ( identifier.as(:key) >> spaces? >> str(':') >> spaces? >> literal.as(:val) ).as(:hash_pair) }
+      rule(:jshash)         { str('{') >> spaces? >> (hash_pair >> (comma >> hash_pair).repeat).maybe.as(:jshash) >> spaces? >> str('}') }
+
+      rule(:function)       { (match('[a-z_]') >> match('[a-z0-9_]').repeat).as(:function_name) >> str('(') >> literal.maybe.as(:param) >> str(')') }
+
+      rule(:expression)     { identifier.as(:id) >> spaces? >> operator.as(:op) >> spaces? >> literal.as(:value) >> spaces? }
+      rule(:str_expression) { identifier.as(:id) >> spaces >> not_op.as(:not) >> str_op.as(:op) >> spaces? >> string.as(:str) >> spaces? }
+      rule(:blank_expr)     { identifier.as(:id) >> spaces >> stri('is') >> not_op.as(:not) >> switch_op.as(:switch_op) >> spaces? }
+
+      #rule(:condition)      { lparen >> or_cond >> rparen | expression | str_expression | blank_expr }
+      #rule(:and_cond)       { (condition.as(:left) >> and_op >> and_cond.as(:right)).as(:and) | condition }
+      #rule(:or_cond)        { (and_cond.as(:left) >> or_op >> or_cond.as(:right)).as(:or) | and_cond }
+      rule(:condition)      { expression | str_expression | blank_expr }
+      #rule(:query)          { spaces? >> or_cond >> spaces? }
+      rule(:query)          { spaces? >> ( condition >> (and_op >> condition).repeat ).as(:query) >> spaces? }
+
+      root :query
+    end
+
+    PREDICATE_MAP = {
+      "="        => 'eq',
+      "!="       => 'not_eq',
+      ">="       => 'gteq',
+      "<="       => 'lteq',
+      ">"        => 'gt',
+      "<"        => 'lt',
+      "like"     => 'matches',
+      "notlike"  => 'does_not_match',
+      "cont"     => 'cont',
+      "notcont"  => 'not_cont',
+      "start"    => 'start',
+      "notstart" => 'not_start',
+      "end"      => 'end',
+      "notend"   => 'not_end',
+      "blank"    => 'blank',
+      "notblank" => 'present',
+      "null"     => 'null',
+      "notnull"  => 'not_null',
+    }.freeze
+
+    PREDICATE_MAP_REVERSE = {
+      'eq'             => "=",
+      'not_eq'         => "!=",
+      'gteq'           => ">=",
+      'lteq'           => "<=",
+      'gt'             => ">",
+      'lt'             => "<",
+      'matches'        => "like",
+      'does_not_match' => "not like",
+      'cont'           => "cont",
+      'not_cont'       => "not cont",
+      'start'          => "start",
+      'not_start'      => "not start",
+      'end'            => "end",
+      'not_end'        => "not end",
+      'blank'          => "is blank",
+      'present'        => "is not blank",
+      'null'           => "is null",
+      'not_null'       => "is not null",
+      'true'           => "= true",
+      'false'          => "= false",
+    }.freeze
+
+    class Transformer < Parslet::Transform
+      class HashPair < Struct.new(:key, :val); end
+
+      rule(:string     => simple(:str))    { FilterQL.string_to_value(str.to_s) }
+      rule(:integer    => simple(:int))    { Integer(int) }
+      rule(:float      => simple(:float))  { Float(float) }
+      rule(:identifier => simple(:id))     { id.to_sym }
+      rule(:true       => simple(:true))   { true }
+      rule(:false      => simple(:false))  { false }
+      rule(:not        => simple(:n))      { n ? :not : nil }
+
+      rule(:function => { :function_name => simple(:fce_name), :param => subtree(:param) }) do
+        b = builder.new_for_slice(fce_name)
+        if f = builder.functions[fce_name.to_sym]
+          f.call(b, param)
+        else
+          b.raise_error("Neznámá funkce `#{fce_name}'")
+        end
+      end
+
+      rule(:array => subtree(:ar)) { Array(ar) }
+      rule(:jshash => subtree(:ob)) do
+        (ob.is_a?(Array) ? ob : [ ob ]).inject({}) { |h, e| h[e.key] = e.val; h }
+      end
+      rule(:hash_pair => { :key => simple(:ke), :val => simple(:va) }) { HashPair.new(ke, va) }
+
+      rule(id: simple(:id), op: simple(:op), value: subtree(:value)) do
+        { "#{id}_#{PREDICATE_MAP[op.to_s]}" => value }
+      end
+
+      rule(id: simple(:id), not: simple(:n), op: simple(:op), str: simple(:value)) do
+        predicate = PREDICATE_MAP["#{n}#{op}"]
+        { "#{id}_#{predicate}" => value }
+      end
+
+      rule(id: simple(:id), not: simple(:n), switch_op: simple(:value)) do
+        predicate = PREDICATE_MAP["#{n}#{value}"]
+        { "#{id}_#{predicate}" => true }
+      end
+
+      rule(:query => subtree(:conditions)) do 
+        Array.wrap(conditions).inject({}) {|result, cond| result.merge(cond)}
+      end
+    end
+
+    class Builder
+      attr_reader :query, :options, :slice
+
+      def initialize(query, options, slice = nil)
+        @query = query
+        @options = options
+        @slice = slice
+      end
+
+      def functions
+        @options[:functions] || {}
+      end
+
+      def raise_error_for_pos(message, pos, line = '?', column = '?')
+        query_error = pos >= query.length ? "#{query}(<=CHYBA)" : query.dup.insert(pos, "(<=CHYBA)")
+        raise ParseError, "#{message} na řádku #{line} sloupec #{column}: \"#{query_error}\""
+      end
+
+      def raise_error(message)
+        if slice
+          line, column = slice.line_and_column
+          raise_error_for_pos(message, slice.offset + slice.size, line, column)
+        else
+          raise ParseError, message
+        end
+      end
+
+      def new_for_slice(slice)
+        Builder.new(query, options, slice)
+      end
+    end
+
+    def initialize(options = nil)
+      @parser = Parser.new
+      @transformer = Transformer.new
+      @options = (options || {}).freeze
+    end
+
+    def parse(query, options = nil)
+      builder = Builder.new(query, @options)
+      begin
+        ast = @parser.parse(query, reporter: Parslet::ErrorReporter::Deepest.new)
+        @transformer.apply(ast, builder: builder)
+      rescue Parslet::ParseFailed => e
+        #puts e.cause.ascii_tree
+        deepest = deepest_cause(e.cause)
+        line, column = deepest.source.line_and_column(deepest.pos)
+        builder.raise_error_for_pos("Neočekáváný vstup", deepest.pos, line, column)
+      end
+    end
+
+    #Basepack::FilterQL.test
+    def self.test
+      new(
+        functions: {
+          user: proc {|builder, arg| arg.inspect }
+        }
+      ).parse(
+        "a0 = user() and a01 = user('I') and a02 = user({ x: 1}) and a03 = user([1,2,'3']) and " +
+        "a1 = 3 and a2 like 'asd' and a3 not like 'asd' and a4 is null and a5 is not null and a6 != 'as\\'d' and a7 = \"str\\\"s\" and " +
+        "a8 = { key:'value', key2:1 } and a9 = ['str', 4, 3.5] ",
+      )
+    end
+
+    def self.conditions_to_ql(conditions)
+      conditions.map do |name, predicate_name, value|
+        if predicates[predicate_name][:type] == :boolean
+          "#{name} #{PREDICATE_MAP_REVERSE[predicate_name]}"
+        else
+          case value
+          when String then value = value_to_string(value)
+          when Hash   then value = value_to_jshash(value)
+          end
+          "#{name} #{PREDICATE_MAP_REVERSE[predicate_name]} #{value}"
+        end
+      end.join(" and ")
+    end
+
+    def self.predicates
+      @predicates ||= begin
+        Hash[Ransack.predicates.map do |k, predicate|
+          [k, {
+            name:     k,
+            label:    Ransack::Translate.predicate(k),
+            type:     predicate.type,
+            compound: predicate.compound,
+            wants_array: predicate.wants_array,
+          }]
+        end.compact]
+      end
+    end
+
+    def self.value_to_string(value)
+      "'#{value.gsub(/(['\\])/, '\\\\\1')}'"
+    end
+
+    def self.value_to_jshash(value)
+      res = value.inject([]) do |r,(k,v)|
+        r << "#{k}: #{v.inspect}"
+      end.join(", ")
+      "{ #{res} }"
+    end
+
+    def self.string_to_value(string)
+      string.gsub(/\\(.)/, '\1')
+    end
+
+    private
+
+    def deepest_cause(cause)
+      if cause.children.any?
+        deepest_cause(cause.children.first)
+      else
+        cause
+      end
+    end
+  end
+end

data/lib/basepack/forms/base.rb

@@ -0,0 +1,246 @@
+module Basepack
+  module Forms
+    class Base
+      include Basepack::Renderable
+
+      attr_reader   :groups
+      attr_reader   :factory
+      attr_reader   :resource_class
+      attr_reader   :association_chain
+      attr_accessor :resource
+      attr_accessor :view
+      attr_accessor :partial
+      attr_reader   :nested_in
+
+      def initialize(factory, chain, options = {})
+        @factory     = factory
+        @fields_hash = {}
+        @groups      = []
+        @nested_in   = options[:nested_in]
+
+        chain = Array.wrap(chain)
+        @association_chain = chain[0...-1].freeze
+
+        if chain.last.is_a? Class
+          @resource_class = chain.last
+        else
+          @resource = chain.last
+          @resource_class = @resource.class
+        end
+      end
+
+      def build_from_factory
+        factory.build_form(self)
+      end
+
+      def new_form(*args)
+        form = factory.new_form(*args)
+        form.view = view
+        if configure_nested_form = form.nested_in.try(:configure_nested_form)
+          form.configure(&configure_nested_form)
+        end
+        form
+      end
+
+      def configure(&block)
+        yield(self)
+        self
+      end
+
+      def label
+        @label ||= resource_class.model_name.human
+      end
+
+      def label_plural
+        @label_plural ||= resource_class.model_name.human(count: 'other', default: label.pluralize)
+      end
+
+      def chain
+        @association_chain + [resource]
+      end
+
+      def chain_with_class
+        @association_chain + [resource_class]
+      end
+
+      def resource
+        @resource ||= resource_class.new # TODO - nested_in.build_resource
+      end
+
+      def new_record?
+        !@resource or @resource.new_record?
+      end
+
+      def inverse_of_nested_in?(field) # TODO remove and should be automatical (test in visible_fields or in visible?)
+        field.inverse_of_nested_in?
+      end
+
+      def field_names
+        @fields_hash.keys
+      end
+
+      def fields
+        @fields_hash.values
+      end
+
+      def fields_hash
+        @fields_hash.dup
+      end
+
+      def visible_fields
+        @fields_hash.values.find_all {|f| f.visible? }
+      end
+
+      def has_field?(name)
+        @fields_hash.has_key? name
+      end
+
+      def field(name, delegate_or_attributes = nil)
+        if delegate_or_attributes or block_given?
+          field = @fields_hash[name]
+          if field
+            field.update_attributes(delegate_or_attributes) unless delegate_or_attributes.nil?
+          else
+            field = factory.new_field(name, self, delegate_or_attributes)
+          end
+          yield(field) if block_given?
+          @fields_hash[name] = field
+        else
+          @fields_hash[name]
+        end
+      end
+
+      def visible_field(name)
+        field = @fields_hash[name]
+        field && field.visible? ? field : nil
+      end
+
+      def hide_field(field_name)
+        @fields_hash[field_name].try :visible=, false
+      end
+
+      def hide_fields(*field_names)
+        field_names.each {|f| hide_field(f)}
+      end
+
+      def show_fields(*field_names)
+        field_names.each {|name| @fields_hash[name].try :visible, true }
+      end
+
+      def group(attributes = nil)
+        group = factory.new_group(self, attributes)
+        yield(group) if block_given?
+        @groups << group
+        group
+      end
+
+      def default_group
+        @groups.first
+      end
+
+      def visible_groups
+        groups.find_all {|g| g.field_names.present? }
+      end
+
+      render do
+        view.render @partial || default_partial, form: self
+      end
+
+      def default_partial
+      end
+
+      def render_field(field)
+        field.render
+      end
+
+      def render_field!(field)
+      end
+
+      def content_for_field(field_name, &block)
+        field(field_name) do |f|
+          f.content(&block)
+        end
+      end
+
+      def path
+        view.url_for(chain)
+      end
+
+      def permit_params(params)
+        sanitize_params(params).permit!
+      end
+
+      def sanitize_params(params, add_to_allwed = [])
+        new_params = params.dup
+        allowed = add_to_allwed.dup
+
+        visible_fields.each do |f|
+          next if f.read_only? or f.inverse_of_nested_in?
+
+          f.parse_input(new_params)
+
+          f.allowed_methods.each do |m|
+            if f.type == :serialized or (new_params[m].is_a?(Array) or new_params[m].is_a?(Hash)) ^ !f.multiple?
+              allowed << m
+            end
+          end
+
+          if nform = f.nform and nparams = new_params[f.method_name]
+            # nested_form with accepts_nested_attributes_for needs :id and 
+            # :_destroy params in some cases
+
+            nested_allowed = []
+            field_nested_params = f.nested_form
+            if field_nested_params
+              nested_allowed << :id unless field_nested_params[:update_only]
+              nested_allowed << :_destroy if field_nested_params[:allow_destroy] or nform.new_record?
+            end
+
+            new_params[f.method_name] = case nparams
+            when Array
+              nparams.map {|p| p.is_a?(Hash) ? nform.sanitize_params(p, nested_allowed) : p.to_s}
+            when Hash
+              if f.multiple?
+                Hash[nparams.map do |k, p|
+                  [k, p.is_a?(Hash) ? nform.sanitize_params(p, nested_allowed) : p.to_s]
+                end]
+              else
+                allowed << f.method_name
+                nform.sanitize_params(nparams, nested_allowed)
+              end
+            else
+              nparams
+            end
+          end
+        end
+
+        unpermitted = new_params.slice!(*allowed)
+        if unpermitted.present?
+          ActiveSupport::Notifications.instrument("unpermitted_parameters.action_controller", keys: unpermitted.keys)
+        end
+
+        new_params
+      end
+
+      def with_resource(resource, *args, &block)
+        orig_resource, @resource = @resource, resource
+        begin
+          yield(resource, *args)
+        ensure
+          @resource = orig_resource
+        end
+      end
+
+      def inspect
+        "#<#{self.class.name}[#{resource_class.name}] #{field_names}>"
+      end
+
+      # use more lookup paths for translations
+      def translate(resource, action, subaction = "menu")
+        Utils.translate(resource, action, subaction)
+      end
+
+    end
+  end
+end
+

data/lib/basepack/forms/bulk_edit.rb

@@ -0,0 +1,44 @@
+module Basepack
+  module Forms
+    class BulkEdit < Forms::Edit
+      attr_accessor :query_form
+
+      def initialize(factory, chain, options = {})
+        super(factory, chain, options)
+        @query_form = options[:query_form]
+      end
+
+      def collection
+        @query_form ? @query_form.collection_without_pagination : []
+      end
+
+      def path
+        @path ||= view.polymorphic_path([:bulk_update, chain].flatten, query_form.params)
+      end
+
+
+      def build_from_factory
+        factory.build_form(self)
+      end
+
+      def default_partial
+        'forms/bulk_edit'
+      end
+
+      def render_field!(field)
+        if field.bulk_editable? and !field.read_only? and field.view_helper != :hidden_field
+          field.required = false
+          if field.bulk_edit_partial.present? and view.lookup_context.template_exists?(field.bulk_edit_partial, '', true)
+            #rendering input field with bulk_edit extensions
+            view.render field.bulk_edit_partial, form: self, field: field
+          else
+            #rendering common input field
+            view.render field.partial, form: self, field: field
+          end
+        end
+      end
+
+
+    end
+  end
+end