lanes 0.1.9.5 → 0.3.0

data/lib/lanes/api/default_routes.rb

@@ -1,16 +1,18 @@
 module Lanes
     API.routes.draw do
-        get "default-records" do
-            { success: true, data: Lanes::API.default_records }
-        end
 
-        Extensions.each do | ext |
+        put Lanes.config.api_path + 'system-settings.json',
+            &SystemSettings.update_handler
+
+        post Lanes.config.api_path + 'save-file-attribute',
+             &API::Handlers::File.saver
+
+        get Lanes.config.api_path + 'file/*',
+            &API::Handlers::File.getter
+
+        Extensions.each(reversed: true) do | ext |
             ext.route(self)
         end
 
-        get '/*' do
-            content_type 'text/html'
-            erb :index
-        end
     end
 end

data/lib/lanes/api/formatted_reply.rb

@@ -0,0 +1,53 @@
+module Lanes
+    module API
+        module FormattedReply
+            # json methods
+            # constructs a Hash with success, messages, and data keys and
+            # populates them appropriately
+
+            def std_api_reply(type, data, options)
+                success = options[:success].nil? ? true : options[:success]
+                json = {}
+                if data.is_a?(ActiveRecord::Base) && data.errors.any?
+                    json[:errors] = {}
+                    success = false
+                    data.errors.each{ | attr, message |
+                        json[:errors][attr] = message
+                    }
+                end
+                if options[:total_count]
+                    json[:total] = options.delete(:total_count)
+                end
+                json.merge(
+                  success: success,
+                  message: options[:messsage] || json_status_str(data, type.to_s.capitalize, success),
+                  data:    success ? records_for_reply(data, type, options) : []
+                )
+            end
+
+            # @return Array<Array> returns either an array of fields
+            def records_for_reply(data, type, options)
+                return [] if :destroy == type
+                if options[:format] == 'array'
+                    data.pluck( *requested_fields )
+                else
+                    data.as_json(options)
+                end
+            end
+
+            def json_status_str(record, type, success)
+                if success
+                    type + " succeeded"
+                elsif record
+                    msg = type + " failed"
+                    if record.is_a?(ActiveRecord::Base)
+                        msg += ": " + record.errors.full_messages.join("; ")
+                    end
+                else
+                    return "Record not found"
+                end
+            end
+
+        end
+    end
+end

data/lib/lanes/api/handlers/file.rb

@@ -0,0 +1,26 @@
+module Lanes::API::Handlers
+
+    class File
+
+        def self.saver
+            lambda do
+                Lanes.logger.debug "Saving File. Root=#{CarrierWave.root}"
+                path = "#{params['extension_id']}/#{params['type']}"
+                model = path.underscore.camelize.constantize
+                record = model.find(params['id'])
+                params['files'].each do |attr, data|
+                    record.send(attr).store!( data )
+                end
+                record.save!
+
+                json_reply std_api_reply :create, { model: record }, success: true
+            end
+        end
+
+        def self.getter
+            lambda do
+                send_file CarrierWave::Uploader::Base.root.call + '/' + params['splat'].first
+            end
+        end
+    end
+end

data/lib/lanes/api/helper_methods.rb

@@ -3,12 +3,16 @@ module Lanes
 
         module HelperMethods
 
-            def lanes_javascript_tag
-                javascript_tag( 'lanes' )
+            def lanes_application_title
+                Extensions.controlling.title
             end
 
-            def lanes_stylesheet_tag
-                stylesheet_tag( 'lanes' )
+            def lanes_javascript_tags
+                javascript_tag('lanes/vendor') + "\n" + javascript_tag('lanes')
+            end
+
+            def lanes_stylesheet_tags
+                stylesheet_tag('lanes')
             end
 
             def client_bootstrap_data
@@ -20,12 +24,32 @@ module Lanes
             end
 
             def lanes_api_url
-                Lanes.config.mounted_at
+                Lanes.config.api_path
+            end
+
+            def error_as_json
+                Lanes.logger.warn request.env['sinatra.error']
+                Oj.dump({
+                    success: false,
+                    errors:  { exception: request.env['sinatra.error'].message },
+                    message: request.env['sinatra.error'].message
+                })
             end
 
             def data
                 @json_data ||= Oj.load( request.body.read )
             end
+
+            def request_origin
+                @request_origin ||= env['HTTP_ORIGIN']
+            end
+
+            def json_reply( response )
+                content_type 'application/json'
+                Oj.dump(response, mode: :compat)
+            end
+
+
         end
 
     end

data/lib/lanes/api/javascript_processor.rb

@@ -19,30 +19,49 @@ module Lanes
                 end
             end
 
+            def get_js_aliases(ns)
+                ext = Extensions.for_identifier(ns)
+                aliases = ext ? ext.client_js_aliases : {}
+                aliases.merge!({
+                    'LC'    => 'window.Lanes.Components',
+                    'React' => 'window.Lanes.Vendor.React',
+                    'BS'    => 'window.Lanes.Vendor.ReactBootstrap'
+                 })
+                [ aliases.keys.join(','), aliases.values.join(',') ]
+            end
+
+            def get_wrapping_vars(identifier)
+                if identifier
+                    ns = identifier.underscore.camelize
+                else
+                    ns = ''
+                    identifier = ''
+                end
+                if identifier == "lanes"
+                    ns_file_ref = "window.Lanes"
+                    ns_ref = ''
+                    ns_name = ''
+                else
+                    ns_name = "#{ns},"
+                    ns_ref = "(window.Lanes ? window.Lanes['#{ns}'] : null),"
+                    ns_file_ref = "window.Lanes['#{ns}']"
+                end
+                return ns, ns_file_ref, ns_ref, ns_name
+            end
+
             def wrap_js(scope, js)
                 dirs = scope.logical_path.split(File::SEPARATOR)
-                ns   = dirs.many? ? dirs.first.camelize : nil
+                identifier   = dirs.many? ? dirs.first : nil
                 path = "[" + dirs.map{|d| "\"#{d}\"" }.join(",") + "]"
                 # if the file is being loaded under the "lanes" directory
                 # it's not an extension
-                if ns && ns != "Lanes"
-                    ns = ns.underscore.camelize
-                    ns_name = "#{ns},"
-                    ns_ref = "(window.Lanes ? window.Lanes['#{ns}'] : null),"
-                    ns_file_ref = "window.Lanes['#{ns}']"
-                else
-                    ns_name = ""
-                    ns_ref = ""
-                    ns_file_ref = "window.Lanes"
-                end
-                file="{namespace:#{ns_file_ref},extensionName:'#{ns}',path:#{path}}"
-                "(function(Lanes,#{ns_name}_,LC,React,BS,FILE,window,undefined)"\
+                (aliases, definitions) = get_js_aliases(identifier)
+                ns, ns_file_ref, ns_ref, ns_name = get_wrapping_vars(identifier)
+                file="{namespace:#{ns_file_ref},extension:{name:'#{ns}',identifier:'#{identifier}'},path:#{path}}"
+                "(function(Lanes,#{ns_name}_,#{aliases},FILE,window,undefined)"\
                     "{\n#{js}\n})"\
                     "(window.Lanes,#{ns_ref}window.Lanes.Vendor.ld,"\
-                    "window.Lanes.Components,"\
-                    "window.Lanes.Vendor.React,"\
-                    "window.Lanes.Vendor.ReactBootstrap,"\
-                    "#{file}, window);"
+                    "#{definitions},#{file},window);"
             end
 
         end

data/lib/lanes/api/pub_sub.rb

@@ -6,6 +6,7 @@ module Lanes
         class PubSub
 
             def self.publish(channel, data)
+                Lanes.logger.debug "publishing on: #{channel}"
                 ::MessageBus.publish channel, data
             end
 
@@ -20,16 +21,12 @@ module Lanes
                 require 'message_bus'
                 api.use MessageBus::Rack::Middleware if api
 
-                # Use OJ - it encodes dates properly as ISO 8601
-                # https://github.com/moment/moment/issues/1407
-                Oj.mimic_JSON()
-                # # Requiring json here seems to stop conflicts when requiring json in other files.
-                begin
-                    require 'json'
-                rescue
-                    # ignore
+                if defined?(::PhusionPassenger)
+                    PhusionPassenger.on_event(:starting_worker_process) do |forked|
+                        MessageBus.after_fork if forked
+                    end
                 end
-                ::MessageBus.redis_config = Lanes.config.redis
+
                 Updates.relay!
 
                 ::Lanes::API.routes.draw do

data/lib/lanes/api/request_wrapper.rb

@@ -67,8 +67,7 @@ module Lanes
                 if false == response[:success]
                     status(406)
                 end
-                content_type 'application/json'
-                Oj.dump(response, mode: :compat)
+                json_reply response
             end
 
         end

data/lib/lanes/api/root.rb

@@ -1,65 +1,32 @@
 require 'sinatra'
 require 'oj'
-require 'rack/csrf'
-
+require 'rack/protection'
 require_relative 'sprockets_extension'
 require_relative 'helper_methods'
 require_relative 'pub_sub'
 
+
 module Lanes
     module API
         class Root < Sinatra::Application
+
             Lanes.config.get(:environment) do | env |
                 set :environment, env
             end
             register SprocketsExtension
             helpers RequestWrapper
             helpers HelperMethods
+            helpers FormattedReply
             use Rack::Session::Cookie, :key => 'lanes.session', :secret => Lanes.config.session_secret_key_base
             use ActiveRecord::ConnectionAdapters::ConnectionManagement
             not_found do
                 Oj.dump({ message: "endpoint not found", success: false  })
             end
-            error do
-                Lanes.logger.warn request.env['sinatra.error']
-                Oj.dump({
-                    success: false,
-                    errors:  { exception: request.env['sinatra.error'].message },
-                    message: request.env['sinatra.error'].message
-                })
+            error ActiveRecord::RecordNotFound do
+                halt 404, error_as_json
             end
-
-            def self.resources(model, options = {})
-
-                path = options[:path] || model.api_path
-                controller = options[:controller] || Lanes::API::Controller
-
-                parent_attribute = false
-                prefix = if options[:under]
-                             parent_attribute = options[:parent_attribute] || options[:under].underscore.singularize+'_id'
-                         else
-                             ''
-                         end
-
-                # index
-                get "#{prefix}/#{path}/?:id?.json", &RequestWrapper.get(model, controller, parent_attribute)
-
-                # create
-                post "#{prefix}/#{path}.json", &RequestWrapper.post(model, controller, parent_attribute)
-
-                unless options[:immutable]
-
-                    # update
-                    patch "#{prefix}/#{path}/?:id?.json", &RequestWrapper.update(model, controller, parent_attribute)
-                    put   "#{prefix}/#{path}/?:id?.json", &RequestWrapper.update(model, controller, parent_attribute)
-
-                    unless options[:indestructible]
-                        # destroy
-                        delete "#{prefix}/#{path}/?:id?.json", &RequestWrapper.delete(model, controller, parent_attribute)
-                    end
-
-                end
-
+            error do
+                error_as_json
             end
 
             configure do
@@ -67,14 +34,15 @@ module Lanes
                 set :show_exceptions, false
                 require_relative 'routing'
 
-                DB.establish_connection
                 PubSub.initialize(self)
                 Extensions.load_controlling_config
                 # late load in case an extension has provided an alternative implementation
                 unless API.const_defined?(:AuthenticationProvider)
                     require "lanes/api/null_authentication_provider"
                 end
-                # use Rack::Csrf, :skip=>['GET:/'], :raise => true
+                use Rack::Protection #, :skip=>['GET:/'], :raise => true
+
+                Lanes::Configuration.apply
             end
 
         end

data/lib/lanes/api/routing.rb

@@ -1,6 +1,64 @@
 module Lanes
     module API
 
+        class RoutingBlock
+            def initialize(ext_id)
+                Lanes::Extensions.for_identifier(ext_id) ||
+                    raise( "Unable to find extension '#{ext_id}' for screen group")
+                @ext_id = ext_id
+            end
+
+            def root_view( view )
+                API::Root.get Lanes.config.mounted_at + '?*' do
+                    pass unless request.accept? 'text/html'
+                    erb view
+                end
+            end
+
+            [:get, :post, :put, :patch, :delete].each do | method_name |
+                define_method(method_name) do | path, options = {}, &block |
+                    API::Root.send(method_name, make_path(path), options, &block)
+                end
+            end
+
+            def resources(model, options = {})
+                path = options[:path] || model.api_path
+                controller = options[:controller] || Lanes::API::Controller
+                parent_attribute = false
+                if options[:under]
+                    parent_attribute = options[:parent_attribute] || options[:under].underscore.singularize+'_id'
+                end
+
+                prefix = parent_attribute ? parent_attribute + '/' : ''
+
+                # index
+                get "#{prefix}#{path}/?:id?.json", &RequestWrapper.get(model, controller, parent_attribute)
+
+                # create
+                post "#{prefix}#{path}.json", &RequestWrapper.post(model, controller, parent_attribute)
+
+                unless options[:immutable]
+
+                    # update
+                    patch "#{prefix}#{path}/?:id?.json", &RequestWrapper.update(model, controller, parent_attribute)
+                    put   "#{prefix}#{path}/?:id?.json", &RequestWrapper.update(model, controller, parent_attribute)
+
+                    unless options[:indestructible]
+                        # destroy
+                        delete "#{prefix}#{path}/?:id?.json", &RequestWrapper.delete(model, controller, parent_attribute)
+                    end
+
+                end
+
+            end
+
+            private
+
+            def make_path(path)
+                Lanes.config.api_path + @ext_id + '/' + path
+            end
+        end
+
         class RouteSet
             def initialize(root)
                 @root = root
@@ -9,6 +67,11 @@ module Lanes
             def draw(&block)
                 @root.instance_eval(&block)
             end
+
+            def for_extension(ext_id, &block)
+                routes = RoutingBlock.new(ext_id)
+                routes.instance_eval(&block)
+            end
         end
 
         def self.routes(&block)

data/lib/lanes/api/sprockets_extension.rb

@@ -1,9 +1,10 @@
 require 'sprockets'
 require 'sass'
 require 'sinatra/sprockets-helpers'
-require_relative 'javascript_processor'
 require 'compass/import-once/activate'
 require 'sprockets-helpers'
+require 'tilt/erb'
+require 'compass/import-once/activate'
 
 module Lanes
     module API
@@ -11,10 +12,15 @@ module Lanes
             class << self
 
                 def compile!
+                    # only require processor if it's needed
+                    # it requires asset pipeline functionality that requires a JS runtime
+                    # which may not be available on production
+                    require_relative 'javascript_processor'
                     env = ::Sprockets::Environment.new
                     Lanes::API::SprocketsExtension.configure(env, compress:true)
+                    JsAssetCompiler.register(env)
                     manifest = Sprockets::Manifest.new( env.index, "public/assets/manifest.json" )
-                    manifest.compile('lanes.js', 'lanes.css')
+                    manifest.compile('lanes/vendor.js', 'lanes.js', 'lanes.css')
                     Extensions.each do |ext|
                         ext.each_static_asset do | asset |
                           manifest.compile( asset.to_s )
@@ -43,14 +49,16 @@ module Lanes
                             env.append_path(path)
                         }
                     end
-
                     if compress
-                        require_relative 'sprockets_compressor'
-                        env.js_compressor  = AssetCompressor
-                        env.css_compressor = AssetCompressor
+                        env.js_compressor  = :uglifier
+                        env.css_compressor = :sass
+                    end
+                    # assets are pre-compiled on production
+                    unless Lanes.env.production?
+                        require_relative 'javascript_processor'
+                        JsAssetCompiler.register(env)
                     end
                     env.append_path root.join('client')
-                    JsAssetCompiler.register(env)
                 end
 
                 def registered(app)