lanes 0.1.2 → 0.1.5

data/lib/lanes/access/role.rb

@@ -0,0 +1,60 @@
+module Lanes
+    module Access
+
+        class Role
+            class_attribute :read, :write, :delete
+
+            def initialize(user)
+                @user = user
+            end
+
+            def can_read?(model)
+                read.include?(model)
+            end
+
+            def can_write?(model)
+                write.include?(model)
+            end
+
+            def can_delete?(model)
+                delete.include?(model)
+            end
+
+            class << self
+                ALL=Array.new
+
+                def grant_global_access(types=[:read,:write,:delete], *klass)
+                    types = [*types]
+                    ALL.each do | child |
+                        types.each{ |type| child.send(type).concat(klass) }
+                    end
+                end
+
+                def inherited(subklass)
+                    ALL << subklass
+                    subklass.read = []; subklass.write = []; subklass.delete = []
+                end
+
+                def grant( *klasses )
+                    self.read.push( *klasses )
+                    write.push( *klasses )
+                    delete.push( *klasses )
+                end
+
+                def lock(klass, attribute)
+                    LockedFields.lock( klass, attribute, self)
+                end
+
+                def lock_writes(klass, attribute)
+                    LockedFields.lock( klass, attribute, self, :write)
+                end
+
+                def all_available
+                    ALL
+                end
+
+            end
+        end
+
+    end
+end

data/lib/lanes/access/role_collection.rb

@@ -0,0 +1,76 @@
+module Lanes
+    module Access
+
+        class RoleCollection
+            include Enumerable
+
+            def initialize(user)
+                @roles ||= user.role_names.map{ |name|
+                    "Lanes::Access::Roles::#{name.classify}".safe_constantize
+                }.compact.map{ |klass| klass.new(user) }
+            end
+
+            def exposed_data
+                @roles.map{ |role| role.class.to_s.demodulize.downcase }
+            end
+
+            # @param model [Lanes::Model]
+            # @param attribute [Symbol]
+            # @return [Boolean] Can the User view the model?
+            def can_read?(model, attribute = nil)
+                klass=model_to_class(model)
+                test_access(klass, attribute, :read){ |role| role.can_read?(klass) }
+            end
+
+            # @param model [Lanes::Model]
+            # @param attribute [Symbol]
+            # @return [Boolean] Can the User create and update the model?
+            def can_write?(model, attribute = nil)
+                klass=model_to_class(model)
+                test_access(klass, attribute, :write){ |role| role.can_write?(klass) }
+            end
+
+            # @param model [Lanes::Model]
+            # @param id  [Fixnum] the id of the record to remove
+            # @return [Boolean] Can the User delete the model?
+            def can_delete?(model,id)
+                klass=model_to_class(model)
+                @roles.each{ |role| role.can_delete?(klass) }
+            end
+
+            # @return [Array<symbol>] list of roles
+            def to_sym
+                @roles.map{ |r| r.class.to_s.demodulize.downcase.to_sym }
+            end
+
+            def each
+                @roles.each{|r| yield r}
+            end
+
+          private
+
+            def model_to_class(model)
+              model.is_a?(Class) ? model : model.class
+            end
+
+            # Test if the given roles grant access to the model
+            def test_access(model, attribute, access_type)
+                # Check if the attribute is locked
+                # If it is, the locks determine access, otherwise use the model's grants
+                roles = LockedFields.roles_needed_for(model, attribute, access_type)
+                if roles.empty?
+                    return !!@roles.detect { |role| yield role }.present?
+                else
+                    roles.any?{ |role| role.models_include?(model) }
+                    #!!roles.find { |role| @roles.map(&:class).include?(role) }
+                end
+            end
+
+        end
+
+    end
+end
+
+
+require_relative "roles/support"
+require_relative "roles/administrator"

data/lib/lanes/access/roles/administrator.rb

@@ -0,0 +1,39 @@
+module Lanes
+    module Access
+
+        module Roles
+
+            class Administrator < Role
+
+                def self.grant_global_access!
+
+                    self.grant( *Lanes::Model.descendants )
+
+                    LockedFields.definitions.each do | klass, fields |
+                        fields.each do |field, grants|
+                            grants.push({ role: self, only: nil })
+                        end
+                    end
+                end
+
+
+                def can_read?(model)
+                    true
+                end
+
+                def can_write?(model)
+                    true
+                end
+
+                def can_delete?(model)
+                    true
+                end
+
+                lock User, :password_digest
+
+            end
+
+        end
+
+    end
+end

data/lib/lanes/access/roles/support.rb

@@ -0,0 +1,15 @@
+require_relative '../user'
+
+module Lanes
+    module Access
+
+        module Roles
+
+            class Support < Role
+                self.read << ::Lanes::User
+            end
+
+        end
+
+    end
+end

data/lib/lanes/access/track_modifications.rb

@@ -0,0 +1,48 @@
+module Lanes::Concerns
+
+    # Extends Rails updated_by and created_by timestamps to also track who created and updated the model.
+    # It reads the current user's id from User.current_id when saving and updating the record
+    # The class_name for the created_by and updated_by is set to {Lanes::Configuration#user_model}
+    module TrackModifications
+        extend ActiveSupport::Concern
+
+        included do
+            class_attribute :record_modifications, :instance_writer=>false
+            self.record_modifications = true
+
+            belongs_to :created_by, :class_name=>Lanes::User
+            belongs_to :updated_by, :class_name=>Lanes::User
+
+            self.blacklist_attributes :created_at, :updated_at, :created_by_id, :updated_by_id
+            before_update :record_update_modifications
+            before_create :record_create_modifications
+        end
+
+        private
+
+        def _record_user_to_column( column )
+            user_id = Lanes::User.current_id ? Lanes::User.current_id : 0
+            write_attribute( column, user_id ) if self.class.column_names.include?( column )
+        end
+
+        def record_create_modifications
+            if self.record_modifications
+                _record_user_to_column('updated_by_id')
+                _record_user_to_column('created_by_id')
+            end
+            true
+        end
+
+        def record_update_modifications
+            if self.record_modifications && should_record_timestamps?
+                _record_user_to_column('updated_by_id')
+            end
+            true
+        end
+
+        def change_tracking_fields
+            %w{updated_by_id created_by_id updated_at created_at}
+        end
+    end
+
+end

data/lib/lanes/access/user.rb

@@ -0,0 +1,128 @@
+module Lanes
+
+    class User < Lanes::Model
+        self.table_name = 'lanes_users'
+
+        has_secure_password
+        validates :login, :name, :email, presence: true
+        validates :email, email: true, uniqueness: { case_sensitive: false }
+        validates :password, length: { minimum: 6 }, allow_nil: true
+
+        whitelist_attributes :password
+
+        def roles
+            @cached_roles ||= Access::RoleCollection.new(self)
+        end
+
+        def workspace_data
+            my_data = attributes.slice('id','login','name','email','created_at',
+              'created_by','updated_at','updated_by','role_names')
+            { user: my_data, access: Access.for_user(self) }
+        end
+
+        # @param model [Lanes::Model]
+        # @param attribute [Symbol]
+        # @return [Boolean] Can the User view the model?
+        def can_read?(model, attribute = nil)
+            roles.can_read?(model, attribute)
+        end
+
+        # @param model [Lanes::Model]
+        # @param attribute [Symbol]
+        # @return [Boolean] Can the User create and update the model?
+        def can_write?(model, attribute = nil)
+            roles.can_write?(model, attribute)
+        end
+
+        # @param model [Lanes::Model]
+        # @param id [Numberic] the id for the model
+        # @return [Boolean] Can the User delete the model?
+        def can_delete?(model, id)
+            roles.can_delete?(model, id)
+        end
+
+        # We override the default implementation so that we can gaurantee
+        # that the current user can always update their own information
+        USER_EDITABLE_ATTRIBUTES=[:name, :email, :password]
+        def setting_attribute_is_allowed?(name, user)
+            ( !new_record? && user.id == self.id && USER_EDITABLE_ATTRIBUTES.include?(name) ) ? true : super
+        end
+        def can_write_attributes?( attr, user )
+            ( !new_record? && user.id == self.id ) ? true : super
+        end
+        def self.can_write_attributes?( attr, user )
+            ( attr[:id] && attr[:id].to_i == user.id ) ? true : super
+        end
+
+
+
+        # If all that's needed is the user's id, see `current_id`,
+        # that method does not not attempt to instantiate a User
+        # Defaults to nil
+        # @return [User] The user who's currently interacting with Lanes.
+        def self.current
+            uid = Thread.current[:lanes_current_user]
+            if uid.is_a?(User)
+                uid
+            else
+                user = Thread.current[:lanes_current_user] = User.find_by_id(uid)
+                return user ? user.id : nil
+            end
+        end
+
+        # Retrieve the current id of the user we're proxying for.
+        # get's a bit complicated since we can proxy both for a user object
+        # or just the user's id
+        # @return [Fixnum] current user's ID.  If the current user is not set, returns 0
+        def self.current_id
+            uid = Thread.current[:lanes_current_user]
+            if uid.nil?
+                0
+            elsif uid.is_a?(User)
+                uid.id
+            else
+                uid
+            end
+        end
+
+        # sets the user for the duration of the block
+        # @example Inside a Rails controller
+        #
+        #     class DocumentsController < ApplicationController
+        #         around_filter :set_lanes_user
+        #
+        #         # update's the Document's owner to current
+        #         # But sets all the notes to be owned by admin
+        #         def update_owner
+        #             doc = Document.find(params[:id])
+        #             doc.current_owner = Lanes::User.current
+        #             Lanes::User.scoped_to( admin_user ) do
+        #                 doc.notes.each{ |note| note.set_owner_to_current! } # will set to Lanese::User.current
+        #             end
+        #         end
+        #
+        #         private
+        #
+        #         def set_lanes_user
+        #             Lanes::User.scoped_to( session[:user_id] ) do
+        #                  yield
+        #             end
+        #          end
+        #      end
+        #
+        # @return [UserProxy] self
+        def self.scoped_to( user )
+            prev_user, Thread.current[:lanes_current_user] = self.current, user
+            yield user
+        ensure
+            Thread.current[:lanes_current_user] = prev_user
+        end
+
+    end
+
+    require_relative "track_modifications"
+
+    # We can only use the TrackModifications concern after the User model is defined
+    Model.send(:include, Concerns::TrackModifications )
+
+end

data/lib/lanes/access/version.rb

@@ -0,0 +1,5 @@
+module Lanes
+    module Access
+        VERSION=0.2
+    end
+end

data/lib/lanes/access.rb

@@ -0,0 +1,51 @@
+require_relative 'workspace'
+
+module Lanes
+
+    module Access
+
+        class << self
+
+            def _type_to_ref(klass)
+                klass.to_s.sub(/^(\w+).*?(\w+)$/,'\1.Models.\2')
+            end
+
+            def _type_to_id(klass)
+                ( klass.is_a?(Class) ? klass : klass.class ).to_s.demodulize.underscore
+            end
+
+            def for_user( user )
+                {
+                    :roles => user.roles.map{ | role |
+                        {
+                            type: _type_to_id(role),
+                            read: role.read.map{ |klass| _type_to_ref(klass) },
+                            write: role.write.map{ |klass| _type_to_ref(klass) },
+                            delete: role.delete.map{ |klass| _type_to_ref(klass) }
+                        }
+                    },
+                    :locked_fields => LockedFields.definitions.map{ | klass, locks |
+                        {
+                            type: _type_to_ref(klass),
+                            locks: locks.each_with_object({}) do |(field, grants), result|
+                                result[field] = grants.map do |grant|
+                                    { role: _type_to_id(grant[:role]), only: grant[:only] }
+                                end
+                            end
+                        }
+                    }
+                }
+            end
+
+        end
+    end
+
+end
+
+require_relative 'access/user'
+require_relative 'access/authentication_provider'
+require_relative 'access/locked_fields'
+require_relative 'access/role'
+require_relative 'access/role_collection'
+require_relative 'access/track_modifications'
+require_relative 'access/extension'

data/lib/lanes/api/helper_methods.rb

@@ -4,11 +4,11 @@ module Lanes
         module HelperMethods
 
             def lanes_javascript_tag
-                javascript_tag( Extensions.require_workspace? ? 'lanes/workspace' : 'lanes/minimal' )
+                javascript_tag( 'lanes' )
             end
 
             def lanes_stylesheet_tag
-                stylesheet_tag( Extensions.require_workspace? ? 'lanes/workspace' : 'lanes/minimal' )
+                stylesheet_tag( 'lanes' )
             end
 
             def client_bootstrap_data

data/lib/lanes/api/javascript_processor.rb

@@ -22,7 +22,7 @@ module Lanes
             def wrap_js(scope, js)
                 dirs = scope.logical_path.split(File::SEPARATOR)
                 ns   = dirs.many? ? dirs.first.camelize : nil
-                file = dirs.last
+                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"
@@ -30,11 +30,11 @@ module Lanes
                     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:'#{file}'});"
+                      "{namespace:#{ref},extensionName:'#{ns}',path:#{path}});"
                 else
                     "(function(Lanes, _, window, FILE, undefined)"\
                       "{\n#{js}\n})(window.Lanes,window._, window,"\
-                      "{namespace:window.Lanes,extensionName:'Lanes',path:'#{file}'});"
+                      "{namespace:window.Lanes,extensionName:'Lanes',path:#{path}});"
                 end
             end
 

data/lib/lanes/api/null_authentication_provider.rb

@@ -24,7 +24,7 @@ module Lanes
                 USER
             end
 
-            def wrap_request(model)
+            def wrap_request(model, req)
                 yield
             end
 

data/lib/lanes/api/pub_sub.rb

@@ -4,15 +4,15 @@ module Lanes
         class PubSub
 
             def self.publish(channel, data)
-                MessageBus.publish channel, data #Oj.dump(data, mode: :compat)
+                MessageBus.publish channel, data
             end
 
-            def self.initialize(api)
+            def self.initialize(api=nil)
                 return unless Extensions.require_pub_sub?
                 require "oj"
                 require_relative "updates"
                 require 'message_bus'
-                api.use MessageBus::Rack::Middleware
+                api.use MessageBus::Rack::Middleware if api
 
                 # Use OJ - it encodes dates properly as ISO 8601
                 # https://github.com/moment/moment/issues/1407

data/lib/lanes/api/request_wrapper.rb

@@ -35,7 +35,7 @@ module Lanes
                           session:      session,
                           params:       params
                         )
-                        authentication.wrap_request(model) do
+                        authentication.wrap_request(model,self) do
                             if parent_attribute
                               params[:nested_attribute] = Hash[ parent_attribute,
                                                                params[parent_attribute] ]

data/lib/lanes/api/root.rb

@@ -23,7 +23,6 @@ module Lanes
             use Rack::Session::Cookie, :key => 'lanes.session', :secret => Lanes.config.session_secret_key_base
             use ActiveRecord::ConnectionAdapters::ConnectionManagement
             error do
-                Lanes.logger.warn request.env['sinatra.error']#.backtrace
                 Oj.dump({
                     success: false,
                     errors:  { exception: request.env['sinatra.error'].message },
@@ -36,7 +35,7 @@ module Lanes
                 set :show_exceptions, false
                 DB.establish_connection
                 PubSub.initialize(self)
-                Extensions.load_current_config
+                Extensions.load_controlling_config
                 # late load in case an extension has provided an alternative implementation
                 require "lanes/api/null_authentication_provider" unless API.const_defined?(:AuthenticationProvider)
                 # use Rack::Csrf, :skip=>['GET:/'], :raise => true

data/lib/lanes/api/sprockets_extension.rb

@@ -15,14 +15,13 @@ module Lanes
                     Lanes::API::SprocketsExtension.configure(env, compress:true)
                     manifest = Sprockets::Manifest.new( env.index, "public/assets/manifest.json" )
                     manifest.compile('lanes/workspace.js', 'lanes/workspace.css',
-                                     'lanes/minimal.js', 'lanes/minimal.css' )
+                                     'lanes/minimal.js',   'lanes/minimal.css' )
                     Extensions.each{|ext|
                         manifest.compile(ext.client_images.map(&:to_s))
                     }
-                    Screens::Definition.each(env) do | screen |
-                        manifest.compile( screen.files )
+                    Screen.each do | screen |
+                        manifest.compile( screen.assets ) unless screen.assets.blank?
                     end
-                    
                 end
 
                 def configure(env, compress:false)
@@ -32,9 +31,12 @@ module Lanes
                             env.cache = ::Sprockets::Cache::FileStore.new(Pathname.pwd.join('tmp','cache'))
                         end
                     end
+
                     Lanes::Extensions.each do | ext |
+                        ext.on_boot
                         ext.client_paths.each{ |path| env.append_path(path) }
                     end
+
                     if compress
                         require_relative 'sprockets_compressor'
                         env.js_compressor  = AssetCompressor

data/lib/lanes/api/test_specs.rb

@@ -1,10 +1,9 @@
 require 'jasmine-core'
-require 'lanes/command'
 
 module Lanes
     module API
 
-        LanesDummyExt = Struct.new(:identifier, :root_path)
+
         class TestSpecs
 
             cattr_accessor :current
@@ -21,7 +20,6 @@ module Lanes
             def js_files
                 urlpath(Jasmine::Core.js_files)   +
                 urlpath(Jasmine::Core.boot_files) +
-                urlpath(spec_files("helpers"))    +
                 urlpath(spec_files(extension.identifier))
             end
 
@@ -40,13 +38,9 @@ module Lanes
             end
         end
 
-
-        ext = Lanes::Command.load_current_extension ||
-          LanesDummyExt.new('lanes', Pathname.new(__FILE__).dirname.join("../../../"))
+        ext = Extensions.controlling
         TestSpecs.current = TestSpecs.new(ext)
         Root.sprockets.append_path(ext.root_path.join("spec"))
-        
-
         Root.sprockets.append_path(Jasmine::Core.path)
 
         routes.draw do

data/lib/lanes/command/app.rb

@@ -9,7 +9,8 @@ module Lanes
 
 
             def load_namespace # override
-                @namespace  = name
+                @namespace  = name.underscore.camelize
+                @identifier = @namespace.underscore.dasherize
             end
 
             def set_variables
@@ -18,16 +19,17 @@ module Lanes
             end
 
             def create_files
-                ["Gemfile", "Rakefile", "Guardfile", "config.ru", "config/database.yml"].each do | file |
-                    template file
+                ["Gemfile", "Rakefile", "Guardfile", "config.ru", "config/database.yml"].each do | file |                    template file
                 end
-                template "lib/namespace.rb", "lib/#{name}.rb"
-                template "lib/namespace/version.rb", "lib/#{name}/version.rb"
-                template "lib/namespace/extension.rb", "lib/#{name}/extension.rb"
-                template "lib/namespace/base_model.rb", "lib/#{name}/model.rb"
+                template "lib/namespace.rb", "lib/#{identifier}.rb"
+                template "lib/namespace/version.rb", "lib/#{identifier}/version.rb"
+                template "lib/namespace/extension.rb", "lib/#{identifier}/extension.rb"
+                template "lib/namespace/base_model.rb", "lib/#{identifier}/model.rb"
                 template "config/routes.rb"
                 template "config/lanes.rb"
                 template "gitignore",".gitignore"
+                create_file "lib/#{identifier}/models/empty.rb",""
+                create_file "log/.gitkeep",""
                 create_file "tmp/.gitkeep",""
                 create_file "db/.gitkeep", ""
                 create_file "config/screens.rb"
@@ -41,18 +43,34 @@ module Lanes
                 end
                 template "client/models/BaseModel.coffee", "#{client_dir}/models/Base.coffee"
                 template "client/views/BaseView.coffee",   "#{client_dir}/views/Base.coffee"
-                template "client/index.js",         "#{client_dir}/index.js"
-                template "client/Extension.coffee", "#{client_dir}/Extension.coffee"
-                template "client/styles.scss",      "#{client_dir}/styles.scss"
+                template "client/index.js",                "#{client_dir}/index.js"
+                template "client/Extension.coffee",        "#{client_dir}/Extension.coffee"
+                template "client/Router.coffee",           "#{client_dir}/Router.coffee"
+                template "client/styles.scss",             "#{client_dir}/styles.scss"
             end
 
-            def create_spec
-
+            def create_spec_helpers
+                template "spec/client/helpers/ClientHelpers.coffee",
+                         "#{spec_dir}/helpers/#{namespace}Helpers.coffee"
+                template "spec/server/spec_helpers.rb",
+                         "spec/server/spec_helpers.rb"
             end
 
             def create_first_screen
+                options = self.options.dup
+                @class_name = "Base"
+                @template = "<div><h1>Base Screen</h1></div>"
+                options[:description] = "Base Screen for #{namespace.titleize}"
+                options[:fileless] = true
+                screen_id = 'base'
                 template "client/screens/Screen.coffee", "#{client_dir}/screens/Base.coffee"
+                template "spec/client/Screen.coffee",    "#{spec_dir}/screens/Base.coffee"
+                insert_into_file "config/screens.rb", after: "" do
+                    source = File.expand_path(find_in_source_paths("config/screen.rb"))
+                    ERB.new(::File.binread(source), nil, "-","@output_buffer").result(binding)
+                end
             end
+
         end
 
     end