lanes 0.1.9 → 0.1.9.5

data/lib/lanes/access/role.rb

@@ -58,12 +58,16 @@ module Lanes
                     delete_types.push(*klasses)
                 end
 
-                def lock(klass, attribute)
-                    LockedFields.lock(klass, attribute, self)
+                def lock(klass, *attributes)
+                    attributes.each do | attr |
+                        LockedFields.lock(klass, attr, self)
+                    end
                 end
 
-                def lock_writes(klass, attribute)
-                    LockedFields.lock(klass, attribute, self, :write)
+                def lock_writes(klass, *attributes)
+                    attributes.each do | attr |
+                        LockedFields.lock(klass, attr, self, :write)
+                    end
                 end
 
                 def all_available

data/lib/lanes/api.rb

@@ -3,9 +3,10 @@ require_relative 'api/request_wrapper'
 require_relative 'api/error_formatter'
 require_relative 'api/controller'
 require_relative 'api/root'
-require_relative 'api/routing'
-require_relative "api/pub_sub"
 
 Lanes.config.get(:environment) do
-    require_relative("api/test_specs") if Lanes.env.test?
+    require_relative("api/test_specs") unless Lanes.env.production?
 end
+
+
+require_relative 'api/default_routes'

data/lib/lanes/api/coffeescript_processor.rb

@@ -7,6 +7,8 @@
 # The second issue is that if a constructor isn't present, coffeescript with generate it's own
 # blank implementation that fails to call "super".  We add a constructor that does call super if one's missing.
 
+require 'coffee-react'
+
 module Lanes
     module API
         class CoffeeScriptProcessor < JsAssetCompiler
@@ -28,36 +30,75 @@ module Lanes
                     end
                 end
 
+                def setup_properties
+                    ensure_property("constructor", "-> super")
+                    ensure_property("FILE", "FILE")
+                end
+
+                def save
+                    file_contents.gsub!(/^(\s*class #{name}\n.*?)(\n\w|\Z)/m,
+                                        "\\1\n#{extends}.extend(#{name})\n\\2")
+                end
+            end
+
+            class ReactCoffeeClass < CoffeeClass
+
+                def setup_properties
+                    ensure_property("FILE", "FILE")
+                    ensure_property("displayName", "'#{@name}'")
+                end
+
                 def save
-                    file_contents.gsub!( /(class #{name}\n.*?)(\n\w|\Z)/m,
-                                         "\\1\n#{extends}.extend(#{name})\n\\2" )
+                    file_contents.gsub!( /^(\s*class #{name}\n.*?)(\n\w|\Z)/m,
+                                         "\\1\n#{name} = #{extends}.extend(#{name})\n\\2" )
                 end
             end
 
+
             self.registered_extension = '.coffee'
 
             attr_reader :contents
 
             CONSTRUCTOR = /constructor\s*:/
 
-            EXTENDING_CLASS_DEFINITION = /class\s+([\w|\.]+)\s+extends\s+([\w|\.]+)\s*?\n/
+            EXTENDING_CLASS_DEFINITION = /^\s*class\s+([\w|\.]+)\s+extends\s+([\w|\.]+)\s*?(\n|\#)/
 
             def cleaned
                 @contents = data.dup
                 data.scan(EXTENDING_CLASS_DEFINITION) do |match|
                     (name, extends) = match
-                    cc = CoffeeClass.new(name, extends, contents)
-                    cc.ensure_property("constructor", "-> super")
-                    cc.ensure_property("FILE", "FILE")
+                    cc = if extends =~ /\.(React|Screens|Components)\./
+                             ReactCoffeeClass.new(name, extends, contents)
+                         else
+                             CoffeeClass.new(name, extends, contents)
+                         end
+                    cc.setup_properties
                     cc.save
                 end
                 contents
             end
 
+
             def evaluate(scope, locals, &block)
                 wrap_js scope, ::CoffeeScript.compile(cleaned, bare: true)
             end
+        end
+
+        class CjsxProcessor < CoffeeScriptProcessor
 
+            self.registered_extension = '.cjsx'
+
+            def evaluate(scope, locals, &block)
+                begin
+                    coffee = CoffeeReact.transform(cleaned)
+                    js = ::CoffeeScript.compile(coffee, bare: true)
+                    wrap_js scope, js
+                rescue => e
+                    Lanes.logger.warn e
+                    Lanes.logger.warn cleaned
+                    raise e
+                end
+            end
 
         end
     end

data/lib/lanes/api/controller.rb

@@ -81,7 +81,7 @@ module Lanes
                     end
                 end
                 options = build_reply_options.merge(success: success)
-                build_reply(records, :update, options)
+                build_reply(records, :destroy, options)
             end
 
             def perform_multiple_updates
@@ -151,13 +151,14 @@ module Lanes
                 json.merge(
                   success: success,
                   message: options[:messsage] || json_status_str(query, type.to_s.capitalize, success),
-                  data:    success ? records_for_reply(query, options) : []
+                  data:    success ? records_for_reply(query, type, options) : []
                 )
             end
 
 
             # @return Array<Array> returns either an array of fields
-            def records_for_reply(query,options)
+            def records_for_reply(query, type, options)
+                return [] if :destroy == type
                 if reply_with_array?
                     query.pluck( *requested_fields )
                 else

data/lib/lanes/api/default_routes.rb

@@ -0,0 +1,16 @@
+module Lanes
+    API.routes.draw do
+        get "default-records" do
+            { success: true, data: Lanes::API.default_records }
+        end
+
+        Extensions.each do | ext |
+            ext.route(self)
+        end
+
+        get '/*' do
+            content_type 'text/html'
+            erb :index
+        end
+    end
+end

data/lib/lanes/api/javascript_processor.rb

@@ -27,80 +27,26 @@ module Lanes
                 # it's not an extension
                 if ns && ns != "Lanes"
                     ns = ns.underscore.camelize
-                    ref = "(window.Lanes ? window.Lanes['#{ns}'] : null)"
-                    "(function(Lanes, #{ns}, _, window, FILE, undefined)"\
-                      "{\n#{js}\n})(window.Lanes,#{ref},window._, window,"\
-                      "{namespace:#{ref},extensionName:'#{ns}',path:#{path}});"
+                    ns_name = "#{ns},"
+                    ns_ref = "(window.Lanes ? window.Lanes['#{ns}'] : null),"
+                    ns_file_ref = "window.Lanes['#{ns}']"
                 else
-                    "(function(Lanes, _, window, FILE, undefined)"\
-                      "{\n#{js}\n})(window.Lanes,window._, window,"\
-                      "{namespace:window.Lanes,extensionName:'Lanes',path:#{path}});"
+                    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)"\
+                    "{\n#{js}\n})"\
+                    "(window.Lanes,#{ns_ref}window.Lanes.Vendor.ld,"\
+                    "window.Lanes.Components,"\
+                    "window.Lanes.Vendor.React,"\
+                    "window.Lanes.Vendor.ReactBootstrap,"\
+                    "#{file}, window);"
             end
 
         end
 
-        # class CoffeeScriptWrapper < JsAssetCompiler
-        #     self.registered_extension = '.coffee'
-
-        #     CONSTRUCTOR = /constructor\s*:/
-        #     CLASS_DEFINITION = /\s*class\s+([\w|\.]+)/
-        #     EXTENDING_CLASS = /class\s+([\w|\.]+)\s+extends\s+([\w|\.]+)\s*?\n/
-
-        #     # Coffeescript has two shortcomings with regards to Lanes
-        #     #
-        #     # The first is that it's extends format is incompatible with AmpersandState,
-        #     # State does quite a bit more via it's own .extend methods.
-        #     # Accordingly, we substitute our own "extend" call whenever we encounter a coffeescript extends
-        #     #
-        #     # The second issue is that if a constructor isn't present, coffeescript with generate it's own
-        #     # blank implementation that fails to call "super".  We add a constructor that does call super if one's missing.
-
-        #     def cleaned
-        #         contents = data.dup
-        #         data.scan(CLASS_DEFINITION) do |match|
-        #             (name, extends) = match
-        #             definition = get_definition(name)
-
-
-        #             # is it missing a constructor?
-        #             if definition !~ /constructor:/
-        #                 # figure out how much to indent, sigh.
-        #                 indent = definition[/\n(\s+)(\w+):/,1] || '    '
-        #                 contents.gsub!(/class #{name}\n/,"\\0#{indent}constructor: -> super\n")
-
-        #             end
-        #             contents.gsub!( /(class #{name}\n.*?)(\n\w|\Z)/m, "\\1\n#{extends}.extend(#{name})\n\\2" )
-
-        #             contents
-        #             #contents << "#{extends}.extend(#{name})\n"
-        #         end
-        #         contents
-        #     end
-
-        #     def evaluate(scope, locals, &block)
-        #         wrap_js scope, ::CoffeeScript.compile(cleaned, bare: true)
-        #     end
-
-        #     def get_definition(name)
-        #         contents.gsub!(/class\s+#{name}\s+.*?\n/,"class #{name}\n")
-        #                        definition = contents[/(class #{name}\n.*?)(\n\w|\Z)/m,1]
-        #     end
-        # end
-
-        class Es6Compiler < JsAssetCompiler
-            self.registered_extension = '.es6'
-            def evaluate(scope, locals, &block)
-                cmd = "#{Lanes.config.es6_transpiler_path} #{Lanes.config.es6_transpiler_options}"
-                stdout, stderr, _status = Open3.capture3(cmd, stdin_data: data)
-                if stderr.empty?
-                    wrap_js scope, stdout
-                else
-                    raise TranspileError, stderr
-                end
-            end
-        end
-
         class JSWrapper < JsAssetCompiler
             self.registered_extension = '.lanes'
             def evaluate(scope, locals, &block)

data/lib/lanes/api/pub_sub.rb

@@ -1,14 +1,20 @@
+require 'message_bus'
+
 module Lanes
     module API
 
         class PubSub
 
             def self.publish(channel, data)
-                MessageBus.publish channel, data
+                ::MessageBus.publish channel, data
             end
 
             def self.initialize(api=nil)
-                return unless Extensions.require_pub_sub?
+                #return unless Extensions.require_pub_sub?
+                Lanes.config.get(:environment) do | env |
+                    MessageBus.logger = Lanes.logger
+                end
+
                 require "oj"
                 require_relative "updates"
                 require 'message_bus'
@@ -20,11 +26,19 @@ module Lanes
                 # # Requiring json here seems to stop conflicts when requiring json in other files.
                 begin
                     require 'json'
-                rescue Exception
+                rescue
                     # ignore
                 end
                 ::MessageBus.redis_config = Lanes.config.redis
                 Updates.relay!
+
+                ::Lanes::API.routes.draw do
+                    post '/file-change.json' do
+                        ::Lanes::API::PubSub.publish("/file-change", data)
+                        "OK"
+                    end
+                end
+
             end
 
         end

data/lib/lanes/api/request_wrapper.rb

@@ -46,7 +46,7 @@ module Lanes
 
             def log_request
                 Lanes.logger.info "UserID: #{session['user_id']}, Params: #{request.params}"
-                Lanes.logger.debug JSON.pretty_generate(data) unless Lanes.env.production?
+                Lanes.logger.debug JSON.pretty_generate(data) unless Lanes.env.production? or data.nil?
             end
 
             def wrap_reply(with_transaction=true)
@@ -57,7 +57,7 @@ module Lanes
                         response = yield
                         # This is quite possibly a horrible idea.
                         # It enables test specs to reset the db state after a request
-                        if Lanes.env.test? && request.env['HTTP_X_ROLLBACK_AFTER_REQUEST']
+                        if !Lanes.env.production? && request.env['HTTP_X_ROLLBACK_AFTER_REQUEST']
                             Lanes::Model.connection.rollback_db_transaction
                         end
                     end

data/lib/lanes/api/root.rb

@@ -21,6 +21,7 @@ module Lanes
                 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 },
@@ -28,19 +29,6 @@ module Lanes
                 })
             end
 
-            configure do
-                set :views, Pathname.new(__FILE__).dirname.join("../../../views")
-                set :show_exceptions, false
-                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
-            end
-
             def self.resources(model, options = {})
 
                 path = options[:path] || model.api_path
@@ -74,6 +62,21 @@ module Lanes
 
             end
 
+            configure do
+                set :views, Pathname.new(__FILE__).dirname.join("../../../views")
+                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
+            end
+
         end
     end
 end

data/lib/lanes/api/routing.rb

@@ -1,7 +1,6 @@
 module Lanes
     module API
 
-
         class RouteSet
             def initialize(root)
                 @root = root
@@ -16,22 +15,5 @@ module Lanes
             @routes ||= RouteSet.new(API::Root)
         end
 
-        self.routes.draw do
-            get '/' do
-                content_type 'text/html'
-                erb :index
-            end
-
-            get "default-records" do
-                { success: true, data: Lanes::API.default_records }
-            end
-
-            Extensions.each do | ext |
-                ext.route(self)
-            end
-
-        end
-
-
     end
 end

data/lib/lanes/api/sprockets_extension.rb

@@ -21,9 +21,12 @@ module Lanes
                         end
                     end
                     Screen.each do | screen |
-                        assets = screen.assets
-                        manifest.compile(assets) unless assets.empty?
+                        [:js,:css].each do | type |
+                            asset = screen.url_path_for(type)
+                            manifest.compile( asset ) unless asset.blank?
+                        end
                     end
+
                 end
 
                 def configure(env, compress:false)
@@ -36,7 +39,9 @@ module Lanes
 
                     Lanes::Extensions.each do | ext |
                         ext.on_boot
-                        ext.client_paths.each{ |path| env.append_path(path) }
+                        ext.client_paths.each{ |path|
+                            env.append_path(path)
+                        }
                     end
 
                     if compress
@@ -57,11 +62,12 @@ module Lanes
                         ::Sprockets::Helpers.configure do |config|
                             config.environment = app.sprockets
                             config.prefix      = Lanes.config.assets_path_prefix
+
                             config.public_path = app.public_folder
                             config.debug = !app.production?
                             if app.production?
                                 config.manifest = Sprockets::Manifest.new(app.sprockets,
-                                                      "public/assets/manifest.json")
+                                                                          "public/assets/manifest.json")
                             end
                         end
                     end