engine2 1.0.4 → 1.0.9

data/lib/engine2/action/view.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class ViewAction < Action
+        include ActionViewSupport, ActionQuerySupport
+    end
+end

data/lib/engine2/action_node.rb

@@ -0,0 +1,221 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class ActionNode < BasicObject
+        ACCESS_FORBIDDEN ||= ->h{false}
+        attr_reader :parent, :name, :number, :nodes, :recheck_access
+        attr_reader :meta_proc, :access_block
+
+        class << self
+            attr_accessor :count
+        end
+
+        def initialize parent, name, action_class, assets
+            ActionNode.count += 1
+            @number = ActionNode.count
+            @parent = parent
+            @name = name
+            @action = action_class.new(self, assets)
+            @nodes = {}
+        end
+
+        def * &blk
+            @meta_proc = @meta_proc ? @meta_proc.chain(&blk) : blk if blk
+            @action
+        end
+
+        alias :action :*
+
+        def access! &blk
+            ::Kernel.raise E2Error.new("Access for node #{name} already defined") if @access_block
+            @access_block = blk
+        end
+
+        def access_forbidden!
+            access! &ACCESS_FORBIDDEN
+        end
+
+        def check_access! handler
+            !@access_block || @access_block.(handler)
+        end
+
+        def run_scheme name, *args, &blk
+            result = instance_exec(*args, &SCHEMES[name])
+            result.instance_eval(&blk) if blk
+            result
+        end
+
+        def define_node name, action_class = InlineAction.inherit, assets = {}, &blk
+            ::Kernel.raise E2Error.new("ActionNode #{name} already defined") if @nodes[name]
+            node = @nodes[name] = ActionNode.new(self, name, action_class, assets)
+            node.*.pre_run
+            define_singleton_method! name do |&ablk| # forbidden list
+                node.instance_eval(&ablk) if ablk
+                node
+            end
+            node.instance_eval(&blk) if blk
+            node.*.node_defined
+            node
+        end
+
+        def define_action name, action_class = InlineAction.inherit, assets = {}, &blk
+            define_node name, action_class, assets do
+                self.* &blk
+            end
+        end
+
+        def define_invoke name, action_class = InlineAction.inherit, assets = {}, &blk
+            define_node name, action_class, assets do
+                self.*.define_invoke &blk
+            end
+        end
+
+        def define_node_bundle name, *nodes
+            define_singleton_method!(name) do |&blk|
+                if blk
+                    nodes.each{|a|__send__(a, &blk)} # if @nodes[node] ?
+                else
+                    ActionNodeBundle.new(self, nodes)
+                end
+            end
+        end
+
+        def define_singleton_method! name, &blk
+            class << self;self;end.instance_eval do # __realclass__
+                define_method name, &blk
+            end
+        end
+
+        def [] name
+            @nodes[name]
+        end
+
+        def nodes_info handler
+            info = nodes.reduce({}) do |h, (name, a)|
+                action = a.*
+                act = {
+                    action_type: action.action_type,
+                    method: action.http_method,
+                    number: a.number,
+                    terminal: a.nodes.empty?,
+                    meta: !action.meta.empty?
+                }
+
+                act[:access] = true if !recheck_access && a.check_access!(handler)
+                act[:recheck_access] = true if a.recheck_access
+
+                if Handler::development?
+                    act[:action_class] = action.class
+                    act[:access_block] = a.access_block if a.access_block
+                    act[:model] = action.assets[:model]
+                end
+
+                h[name] = act
+                h
+            end
+
+            info.first[1][:default] = true unless nodes.empty?
+            info
+        end
+
+        def access_info handler
+            @nodes.reduce({}) do |h, (name, a)|
+                h[name] = a.check_access!(handler)
+                h
+            end
+        end
+
+        def recheck_access!
+            @recheck_access = true
+        end
+
+        def each_node &blk
+            # no self
+            @nodes.each_pair do |n, a|
+                a.each_node(&blk) if yield a
+            end
+        end
+
+        def to_a_rec root = true, result = [], &blk # optimize
+            if root && (yield self)
+                result << self
+                @nodes.each_pair do |n, a|
+                    if yield a
+                        result << a
+                        a.to_a_rec(false, result, &blk)
+                    end
+                end
+            end
+            result
+        end
+
+        def inspect
+            "ActionNode: #{@name}, action: #{@action.class}, action_type: #{@action.action_type}"
+        end
+
+        def setup_node_tree
+            time = ::Time.now
+
+            model_nodes = {}
+            each_node do |node|
+                if model = node.*.assets[:model]
+                    model_name = model.name.to_sym
+                    model_nodes[model_name] = node.to_a_rec{|a| !a.*.assets[:assoc]}
+                    node.run_scheme(model_name) if SCHEMES[model_name, false]
+                    false
+                else
+                    true
+                end
+            end
+
+            thefts = 0
+            panels = 0
+            each_node do |node|
+                action = node.*
+                model = action.assets[:model]
+                assoc = action.assets[:assoc]
+                if model && assoc
+                    if source_nodes = model_nodes[model.name.to_sym]
+                        source_node = source_nodes.select{|sa| sa.meta_proc && sa.*.class >= action.class}
+                        # source_node = source_nodes.select{|sa| sa.meta_proc && action.class <= sa.*.class}
+                        unless source_node.empty?
+                            raise E2Error.new("Multiple action candidates for #{node.inspect} found in '#{source_node.inspect}'") if source_node.size > 1
+                            # puts "#{node.inspect} => #{source_node.inspect}\n"
+                            action.instance_eval(&source_node.first.meta_proc)
+                            thefts += 1
+                        end
+                    end
+                end
+
+                action.instance_eval(&node.meta_proc) if node.meta_proc
+                true
+            end
+
+            each_node do |node|
+                meta = node.*
+                meta.post_run
+                meta.freeze_action
+                panels += 1 if node.*.is_a? ActionPanelSupport
+                true
+            end
+
+            ::Kernel::puts "ACTION NODES: #{ActionNode.count}, Panels: #{panels}, Thefts: #{thefts}, Time: #{::Time.now - time}"
+        end
+
+        def p *args
+            ::Kernel::p *args
+        end
+    end
+
+    class ActionNodeBundle
+        def initialize node, node_names
+            @node = node
+            @node_names = node_names
+        end
+
+        def method_missing name, *args, &blk
+            @node_names.each{|an| @node[an].__send__(name, *args, &blk)}
+        end
+    end
+end

data/lib/engine2/core.rb

@@ -1,4 +1,5 @@
-#coding: utf-8
+# coding: utf-8
+# frozen_string_literal: true
 
 module PrettyJSON
     def to_json_pretty
@@ -13,9 +14,19 @@ class BigDecimal
     end
 end
 
+class Sequel::SQL::QualifiedIdentifier
+    def to_json(*)
+        "\"#{table}__#{column}\""
+    end
+
+    def to_sym
+        :"#{table}__#{column}"
+    end
+end
+
 class Object
     def instance_variables_hash
-        instance_variables.inject({}) do |h, i|
+        instance_variables.reduce({}) do |h, i|
             h[i] = instance_variable_get(i)
             h
         end
@@ -25,16 +36,24 @@ end
 class Proc
     def to_json(*)
         loc = source_location
-        "\"#<Proc:#{loc.first[/\w+.rb/]}:#{loc.last}>\""
+        loc ? "\"#<Proc:#{loc.first[/\w+.rb/]}:#{loc.last}>\"" : '"source unknown"'
     end
 
     def chain &blk
-        proc = self
+        prc = self
         lambda do |obj|
-            obj.instance_eval(&proc)
+            obj.instance_eval(&prc)
             obj.instance_eval(&blk)
         end
     end
+
+    def chain_args &blk
+        prc = self
+        lambda do |*args|
+            instance_exec(*args, &prc)
+            instance_exec(*args, &blk)
+        end
+    end
 end
 
 class Hash
@@ -107,15 +126,45 @@ class String
             s
         end
     end
+
+    def escape_html
+        Rack::Utils.escape_html(self)
+    end
 end
 
 class Symbol
     def icon
-        "<span class='glyphicon glyphicon-#{self}'></span>"
+        s = self
+        if s[0, 3] == 'fa_'
+            "<i class='fa fa-#{s[3 .. -1]}'></i>"
+        else
+            "<span class='glyphicon glyphicon-#{s}'></span>"
+        end
+    end
+
+    def loc
+        Engine2::LOCS[self]
+    end
+
+    def q col
+        col.qualify self
+    end
+
+    def html body = '', attrs = {}
+        element = self.to_s
+        attrs = attrs.map{|k, v| "#{k}=\"#{v}\""}.join(" ")
+        "<#{element} #{attrs}>#{body}</#{element}>"
     end
+end
 
-    def aicon
-        "<i class='fa fa-#{self}'></i>"
+module Faye
+    class WebSocket
+        module API
+            def send! msg
+                msg = msg.to_json if msg.is_a? Hash
+                send msg
+            end
+        end
     end
 end
 
@@ -125,13 +174,17 @@ class << Sequel
     def split_keys id
         id.split(Engine2::SETTINGS[:key_separator])
     end
+
+    def join_keys keys
+        keys.join(Engine2::SETTINGS[:key_separator])
+    end
 end
 
 class Sequel::Database
     attr_accessor :models, :default_schema
 
     def cache_file
-        "#{Engine2::app}/#{opts[:orig_opts][:name]}.dump"
+        "#{Engine2::SETTINGS.path_for(:db_path)}/#{opts[:orig_opts][:name]}.schema_cache"
     end
 
     def load_schema_cache_from_file
@@ -144,7 +197,6 @@ class Sequel::Database
     end
 end
 
-Sequel.quote_identifiers = false
 Sequel.extension :core_extensions
 Sequel::Inflections.clear
 Sequel.alias_columns_in_joins = true
@@ -161,6 +213,10 @@ module E2Model
     module InstanceMethods
         attr_accessor :skip_save_refresh, :validate_fields
 
+        def key? key
+            @values.key? key
+        end
+
         def has_primary_key?
             pk = self.pk
             pk.is_a?(Array) ? !pk.all?{|k|k.nil?} : !pk.nil?
@@ -236,7 +292,7 @@ module E2Model
                 next if info[:primary_key] && !model.natural_key
 
                 value = values[name].to_s
-                value.strip! unless info[:dont_strip]
+                value.strip! unless value.frozen? || info[:dont_strip]
                 if value.empty?
                     if req = info[:required]
                         errors.add(name, req[:message]) if !req[:if] || req[:if].(self)
@@ -277,7 +333,7 @@ module E2Model
 
         def primary_keys_qualified
             # cache it ?
-            primary_keys.map{|k|k.qualify(table_name)}
+            primary_keys.map{|k|table_name.q(k)}
         end
 
         def primary_keys_hash id
@@ -290,9 +346,35 @@ module E2Model
     end
 
     module DatasetMethods
+        def load *args
+            if entry = self[*args]
+                model.after_load_processors.each do |name, proc|
+                    type_info = model.find_type_info(name)
+                    name_sym = name.to_sym
+                    proc.(entry, name_sym, type_info) if entry.key?(name_sym)
+                end if model.after_load_processors
+                entry
+            end
+        end
+
+        def load_all
+            entries = self.all
+            apply_after_load_processors(model, entries) if model.after_load_processors
+            entries
+        end
+
+        def apply_after_load_processors model, entries
+            model.after_load_processors.each do |name, proc|
+                type_info = model.find_type_info(name)
+                name_sym = name.to_sym
+                entries.each do |entry|
+                    proc.(entry, name_sym, type_info) if entry.key?(name_sym)
+                end
+            end
+        end
 
         def ensure_primary_key
-            pk = @model.primary_keys
+            pk = model.primary_keys
             raise Engine2::E2Error.new("No primary key defined for model #{model}") unless pk && pk.all?
 
             if opts_select = @opts[:select]
@@ -300,7 +382,7 @@ module E2Model
                 opts_select.each do |sel|
                     name = case sel
                         when Symbol
-                            sel.to_s =~ /\w+__(\w+)/ ? $1.to_sym : sel
+                            sel
                         when Sequel::SQL::QualifiedIdentifier
                             sel.column
                         when Sequel::SQL::AliasedExpression
@@ -314,94 +396,82 @@ module E2Model
                 if pk.length == sel_pk.length
                     self
                 else
-                    sels = (pk - sel_pk).map{|k| k.qualify(@model.table_name)}
+                    sels = (pk - sel_pk).map{|k| model.table_name.q(k)}
                     select_more(*sels)
                 end
             else
-                select(*pk.map{|k| k.qualify(@model.table_name)})
+                select(*pk.map{|k| model.table_name.q(k)})
             end
+        end
 
+        def extract_select sel, al = nil, &blk
+            case sel
+            when Symbol
+                yield nil, sel, nil
+            when Sequel::SQL::QualifiedIdentifier
+                yield sel.table, sel.column, al
+            when Sequel::SQL::AliasedExpression, Sequel::SQL::Function
+                sel
+                # extract_select sel.expression, sel.aliaz, &blk
+                # expr = sel.expression
+                # yield  expr.table, expr.column
+            else
+                raise Engine2::E2Error.new("Unknown selection #{sel}")
+            end
         end
 
-        def setup! fields
+        def setup_query fields
             joins = {}
-            type_info = model.type_info
             model_table_name = model.table_name
 
-            @opts[:select].map! do |sel|
+            select = @opts[:select].map do |sel|
                 extract_select sel do |table, name, aliaz|
-                    if table
+                    mdl = if table
                         if table == model_table_name
-                            m = model
+                            model
                         else
-                            a = model.many_to_one_associations[table] # || model.one_to_one_associations[table]
-                            raise Engine2::E2Error.new("Association #{table} not found for model #{model}") unless a
-                            m = a.associated_class
+                            assoc = model.many_to_one_associations[table] || model.many_to_many_associations[table]
+                            raise Engine2::E2Error.new("Association #{table} not found for model #{model}") unless assoc
+                            assoc.associated_class
                         end
-                        # raise Engine2::E2Error.new("Model not found for table #{table} in model #{model}") unless m
-                        info = m.type_info
                     else
-                        info = type_info
+                        model
                     end
 
-                    f_info = info[name]
-                    raise Engine2::E2Error.new("Column #{name} not found for table #{table || model_table_name}") unless f_info
-
-                    table ||= model_table_name
-
-                    if table == model_table_name
+                    mdl_table_name = mdl.table_name
+                    table ||= mdl_table_name
+                    if mdl_table_name == model_table_name
                         fields << name
                     else
-                        fields << :"#{table}__#{name}"
-                        joins[table] = model.many_to_one_associations[table]
+                        fields << table.q(name)
+                        joins[mdl_table_name] ||= model.many_to_one_associations[table] || model.many_to_many_associations[table]
                     end
 
+                    f_info = mdl.type_info[name]
+                    raise Engine2::E2Error.new("Column #{name} not found for table #{table}") unless f_info
                     if f_info[:dummy]
                         nil
-                    # elsif f_info[:type] == :blob_store
-                    #     # (~{name => nil}).as :name
-                    #     # Sequel.char_length(name).as name
-                    #     nil
                     else
-                        if table != model_table_name
-                            if Sequel.alias_columns_in_joins
-                                name.qualify(table).as(:"#{table}__#{name}")
-                            else
-                                name.qualify(table)
-                            end
+                        qname = mdl_table_name.q(name)
+                        if table == model_table_name
+                            qname
                         else
-                            name.qualify(table)
+                            Sequel.alias_columns_in_joins ? qname.as(:"#{table}__#{name}") : qname
                         end
                     end
                 end
-            end
-
-            @opts[:select].compact!
+            end.compact
 
-            joins.reduce(self) do |joined, (table, assoc)|
+            joins.reduce(clone(select: select)) do |joined, (table, assoc)|
                 m = assoc.associated_class
-                keys = assoc[:qualified_key]
-                joined.left_join(table, m.primary_keys.zip(keys.is_a?(Array) ? keys : [keys]))
-            end
-        end
-
-        def extract_select sel, al = nil, &blk
-            case sel
-            when Symbol
-                if sel.to_s =~ /^(\w+)__(\w+?)(?:___(\w+))?$/
-                    yield $1.to_sym, $2.to_sym, $3 ? $3.to_sym : nil
-                else
-                    yield nil, sel, al
+                case assoc[:type]
+                when :many_to_one
+                    keys = assoc[:qualified_key]
+                    joined.left_join(table, m.primary_keys.zip(keys.is_a?(Array) ? keys : [keys]))
+                when :many_to_many
+                    joined.left_join(assoc[:join_table], assoc[:left_keys].zip(model.primary_keys)).left_join(m.table_name, m.primary_keys.zip(assoc[:right_keys]))
+                else unsupported_association
                 end
-            when Sequel::SQL::QualifiedIdentifier
-                yield sel.table, sel.column, al
-            when Sequel::SQL::AliasedExpression, Sequel::SQL::Function
-                sel
-                # extract_select sel.expression, sel.aliaz, &blk
-                # expr = sel.expression
-                # yield  expr.table, expr.column
-            else
-                raise Engine2::E2Error.new("Unknown selection #{sel}")
             end
         end
 
@@ -427,16 +497,27 @@ module Sequel
             @error = error
         end
     end
-
 end
 
 module Engine2
     LOCS ||= Hash.new{|h, k| ":#{k}:"}
     PATH ||= File.expand_path('../..', File.dirname(__FILE__))
-    SETTINGS ||= {key_separator: '|'}
+    SETTINGS ||= {
+        key_separator: '|',
+        app_path: 'app',
+        db_path: 'db',
+        model_path: 'models',
+        view_path: 'views',
+        asset_path: 'assets',
+        conf_path: 'conf',
+        log_path: 'log'
+    }
+
+    def SETTINGS.path_for path
+        "#{self[:app_path]}/#{self[path]}"
+    end unless SETTINGS.frozen?
 
     class << self
-        attr_reader :app
         attr_reader :core_loaded
 
         def database name
@@ -457,8 +538,9 @@ module Engine2
         end
 
         def bootstrap_e2db
-            e2_db_file = (defined? JRUBY_VERSION) ? "jdbc:sqlite:#{@app}/engine2.db" : "sqlite://#{@app}/engine2.db"
-            const_set :E2DB, connect(e2_db_file, loggers: [Logger.new($stdout)], convert_types: false, name: :engine2)
+            e2_db_path = "#{Engine2::SETTINGS.path_for(:db_path)}/engine2.db"
+            e2_db_url = (defined? JRUBY_VERSION) ? "jdbc:sqlite:#{e2_db_path}" : "sqlite://#{e2_db_path}"
+            const_set :E2DB, connect(e2_db_url, loggers: [Logger.new($stdout)], convert_types: false, name: :engine2)
             const_set :DUMMYDB, Sequel::Database.new(uri: 'dummy')
             def DUMMYDB.synchronize *args;end
         end
@@ -466,35 +548,41 @@ module Engine2
         def reload
             @core_loaded = true
             t = Time.now
-            Action.count = 0
+            ActionNode.count = 0
             SCHEMES.user.clear
 
             Sequel::DATABASES.each do |db|
                 db.models.each{|n, m| Object.send(:remove_const, n) if Object.const_defined?(n)} unless db == E2DB || db == DUMMYDB
             end
 
-            load "#{app}/boot.rb"
+            load "#{Engine2::SETTINGS[:app_path]}/boot.rb"
 
             Sequel::DATABASES.each &:load_schema_cache_from_file
-            @model_boot_blk.() if @model_boot_blk
             load 'engine2/models/Files.rb'
             load 'engine2/models/UserInfo.rb'
-            Dir["#{app}/models/*"].each{|m| load m}
+            Dir["#{Engine2::SETTINGS.path_for(:model_path)}/*"].each{|m| load m}
+            @model_boot_blk.() if @model_boot_blk
             puts "MODELS: #{Sequel::DATABASES.reduce(0){|s, d|s + d.models.size}}, Time: #{Time.now - t}"
-            Sequel::DATABASES.each &:dump_schema_cache_to_file
+            Sequel::DATABASES.each do |db|
+                db.dump_schema_cache_to_file
+                db.models.each{|n, m|m.synchronize_type_info}
+            end
 
             send(:remove_const, :ROOT) if defined? ROOT
-            const_set(:ROOT, Action.new(nil, :api, RootMeta, {}))
+            const_set(:ROOT, ActionNode.new(nil, :api, RootAction, {}))
 
             @boot_blk.(ROOT)
-            ROOT.setup_action_tree
-            puts "BOOTSTRAP #{app}, Time: #{Time.new - t}"
+            ROOT.setup_node_tree
+            puts "BOOTSTRAP #{Engine2::SETTINGS[:name]}, Time: #{Time.new - t}"
         end
 
-        def bootstrap app, settings = {}
-            @app = app
+        def bootstrap path, settings = {}
             SETTINGS.merge! settings
-            SETTINGS[:name] ||= File::basename(app)
+            SETTINGS[:path] = path
+            SETTINGS[:name] ||= File::basename(path)
+            SETTINGS.freeze
+            Handler.set :public_folder, "public"
+            Handler.set :views, [SETTINGS.path_for(:view_path), "#{Engine2::PATH}/views"]
             bootstrap_e2db
 
             require 'engine2/pre_bootstrap'