lanes 0.0.3 → 0.0.5

data/lib/lanes/access/role_collection.rb

@@ -1,75 +0,0 @@
-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.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

@@ -1,25 +0,0 @@
-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
-
-                lock User, :password_digest
-            end
-
-        end
-
-    end
-end

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

@@ -1,13 +0,0 @@
-module Lanes
-    module Access
-
-        module Roles
-
-            class Support < Role
-                self.read << User
-            end
-
-        end
-
-    end
-end

data/lib/lanes/access/user_maint_screen.rb

@@ -1,32 +0,0 @@
-require 'pathname'
-
-module Lanes
-    module Access
-
-        class WorkspaceScreen < Workspace::ScreenDefinition
-
-            def specification
-                {
-                    id: 'users-management',
-                    title: 'Users',
-                    description: 'Create and maintain Users',
-                    icon: 'icon-user',
-                    group_id: 'customers',
-                    view: 'UserManagement',
-                    model: 'User'
-                }
-            end
-
-            def asset_path
-                Pathname.new(__FILE__).dirname.join("../../../js/screen").realpath
-            end
-
-            def asset_file_names
-                [ 'lanes/access/users-management.js' ]
-            end
-
-        end
-
-    end
-
-end

data/lib/lanes/access.rb

@@ -1,50 +0,0 @@
-module Lanes
-
-    module Access
-
-        class << self
-
-            def _type_to_str(klass)
-                klass.to_s.demodulize.underscore
-            end
-
-            def for_user( user )
-                {
-                    :roles => user.roles.map{ | role |
-                        {
-                            type: _type_to_str(role.class),
-                            read: role.read.map{ |klass| _type_to_str(klass) },
-                            write: role.write.map{ |klass| _type_to_str(klass) },
-                            delete: role.delete.map{ |klass| _type_to_str(klass) }
-                        }
-                    },
-                    :locked_fields => LockedFields.definitions.map{ | klass, locks |
-                        {
-                            type: _type_to_str(klass),
-                            locks: locks.each_with_object({}) do |(field, grants), result|
-                                result[field] = grants.map do |grant|
-                                    { role: _type_to_str(grant[:role]), only: grant[:only] }
-                                end
-                            end
-                        }
-                    }
-                }
-            end
-
-            def calculate_model_access!
-                Roles::Administrator.grant_global_access!
-            end
-
-
-        end
-    end
-
-end
-
-require_relative 'access/locked_fields'
-require_relative 'access/role'
-require_relative 'access/role_collection'
-
-Lanes::Access.calculate_model_access!
-#    require_relative 'access/user_maint_screen'
-#    require_relative 'access/workspace_extension'

data/lib/lanes/api/asset_pipeline.rb

@@ -1,59 +0,0 @@
-require 'sprockets'
-require 'sass'
-require 'sass-css-importer'
-require 'sinatra/sprockets-helpers'
-require_relative 'javascript_processor'
-
-module Lanes
-    module API
-        module AssetPipeline
-
-            def self.configure(env)
-                root = Pathname.new(__FILE__).dirname.join("../../..")
-                Lanes.config.get(:environment) do
-                    if Lanes.env.development?
-                        env.cache = Sprockets::Cache::FileStore.new(root.join('tmp','cache'))
-                    end
-                end
-                env.append_path root.join('client', 'javascripts')
-                env.append_path root.join('client', 'stylesheets')
-                env.append_path root.join('client', 'screens')
-                env.append_path root.join('client', 'images')
-
-                JsAssetCompiler.register(env)
-            end
-
-            def self.registered(app)
-                app.register Sinatra::Sprockets::Helpers
-
-                app.set :sprockets, Sprockets::Environment.new
-                configure(app.sprockets)
-
-                # The url for client
-                app.set :assets_prefix, '/assets'
-
-                app.set :digest_assets, false
-
-                app.configure do
-
-                    Sprockets::Helpers.configure do |config|
-                        config.environment = app.sprockets
-                        config.prefix      = app.assets_prefix
-                        config.digest      = app.digest_assets
-                        config.public_path = app.public_folder
-                        config.debug = true
-                    end
-                end
-
-                app.configure :test, :development do
-                    app.get "#{app.assets_prefix}/*" do |path|
-                        env_sprockets = request.env.dup
-                        env_sprockets['PATH_INFO'] = path
-                        settings.sprockets.call env_sprockets
-                    end
-                end
-            end
-
-        end
-    end
-end

data/lib/lanes/api/authentication_helper.rb

@@ -1,21 +0,0 @@
-module Lanes
-    module API
-        module AuthenticationHelper
-            def authenticate!(model, type)
-                authentication = Lanes::API.config.authentication_provider.new(environment:env, params:params)
-                unless authentication.allowed_access_to?(model, type)
-                    error!({ errors: {user: "Access Denied"}, message: @authentication.error_message }, 401)
-                end
-                @authentication
-            end
-
-            def authentication
-                @authentication
-            end
-
-            def session
-                env['rack.session']
-            end
-        end
-    end
-end

data/lib/lanes/api/authentication_provider.rb

@@ -1,45 +0,0 @@
-module Lanes
-    module API
-        class AuthenticationProvider
-
-            def initialize(session:nil, params:nil, request_type: type)
-                @session = session
-                @params  = params
-                @request_type = request_type
-            end
-
-            def current_user
-                @current_user ||= Lanes::User.where(id: @session[:user_id]).first
-            end
-
-            def error_message
-                current_user ? "User not found" : error_message_for_access
-            end
-
-            def error_message_for_access
-                return "Unable to " + case @request_type
-                                      when 'GET' then "read"
-                                      when 'POST','PATCH','PUT' then "write"
-                                      when 'DELETE' then "delete"
-                                      else
-                                          "perform action"
-                                      end
-            end
-
-            def allowed_access_to?(klass)
-                return false if current_user.nil?
-                case @request_type
-                when 'GET'
-                    klass.can_read_attributes?(@params,current_user)
-                when 'POST','PATCH','PUT'
-                    klass.can_write_attributes?(@params,current_user)
-                when 'DELETE'
-                    klass.can_delete_attributes?(@params,current_user)
-                else
-                    false
-                end
-            end
-
-        end
-    end
-end

data/lib/lanes/api/default_routes.rb

@@ -1,35 +0,0 @@
-module Lanes
-    module API
-
-        Root.get '/' do
-            content_type 'text/html'
-            erb :index
-        end
-
-        Root.get "default-records" do
-            { success: true, data: Lanes::API.default_records }
-        end
-
-        Root.post "/user-session.json" do
-            wrap_json_reply do
-                user = User.where(login: data['login']).first
-                if user && user.authenticate(data['password'])
-                    session[:user_id] = user.id
-                    { success: true, message: "Login succeeded", data: user.workspace_data }
-                else
-                    { success: false, message: "Login failed", errors: { login: 'failed' }, data: {} }
-                end
-            end
-        end
-
-        Root.delete "/user-session.json" do
-            session.destroy
-            { success: true, message: "Logout succeeded", data: {} }
-        end
-
-        Root.build_route User
-
-
-
-    end
-end

data/lib/lanes/api/skr_templates.rb

@@ -1,60 +0,0 @@
-# Stockor templates compiler
-#
-# This is a hacked together version of Sam Stephenson's Eco
-# project for embedded coffeescript templates.
-#
-# Our version has the various helper functions pre-loaded
-# so the templates themselves are smaller in size.
-# and also includes a "h" helper namespace
-
-require 'pathname'
-require 'tilt'
-module Skr
-    module Workspace
-
-        module EJSSource
-            class << self
-                def path
-                    @path ||=  Pathname.new(__FILE__).dirname.join('eco.js')
-                end
-
-                def contents
-                    @contents ||= path.read
-                end
-
-                def combined_contents
-                    [CoffeeScript::Source.contents, contents].join(";\n")
-                end
-
-                def context
-                    @context ||= ExecJS.compile(combined_contents)
-                end
-
-                def compile(template)
-                    template = template.read if template.respond_to?(:read)
-                    context.call("eco.precompile", template, 'Skr.TemplateWrapper','Skr.View.Helpers')
-                end
-
-            end
-        end
-
-
-        class SkrTemplates < Tilt::Template
-
-            self.default_mime_type = 'application/javascript'
-
-            def evaluate(scope, locals, &block)
-                "Skr.Templates['#{scope.logical_path}']=" + EJSSource.compile(data)
-            end
-
-            def prepare;
-                # NOOP
-            end
-
-            def self.register(app)
-                app.assets.register_engine(".skr", self )
-            end
-
-        end
-    end
-end

data/lib/lanes/concerns/track_modifications.rb

@@ -1,51 +0,0 @@
-class Lanes::User
-end
-
-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/db/seed.rb

@@ -1,27 +0,0 @@
-require 'pathname'
-require 'yaml'
-
-module Lanes
-    module DB
-
-        class Seed
-
-            @@seeds = []
-
-            class << self
-
-                def add(&block)
-                    @@seeds.push(block)
-                end
-
-                # Loads the database with seed models
-                def execute!
-                    @@seeds.each(&:call)
-                end
-
-            end
-
-        end
-
-    end
-end

data/lib/lanes/generators/app/Gemfile

@@ -1,5 +0,0 @@
-source 'https://rubygems.org'
-
-gem "lanes", :path=>"/Users/nas/code/lanes" #"~><%= Lanes::VERSION %>"
-gem "rake"
-gem 'puma'

data/lib/lanes/generators/app/Rakefile

@@ -1,9 +0,0 @@
-require 'lanes'
-require 'puma/control_cli'
-
-args = []
-
-task :dev do
-    args.push('start')
-    Puma::ControlCLI.new(args).run
-end

data/lib/lanes/generators/app/lib/main_class/version.rb

@@ -1,3 +0,0 @@
-module <%= name.camelize %>
-    VERSION=0.1
-end

data/lib/lanes/generators/app/lib/main_class.rb

@@ -1,8 +0,0 @@
-require "lanes"
-require "<%= name %>/version.rb"
-
-# The main namespace for <%= name.camelize %>
-module <%= name.camelize %>
-
-
-end

data/lib/lanes/generators/app.rb

@@ -1,36 +0,0 @@
-module Lanes
-    module Generators
-
-        class App < Thor::Group
-            include Thor::Actions
-
-            class_options :force => :boolean
-
-            class_option :test_framework, :type => :string
-            class_option  :directory, :type=>:string
-
-            argument :name
-
-            def self.source_root
-                Pathname.new(__FILE__).dirname.join("app")
-            end
-
-            def initialize(*args)
-                super
-                self.destination_root = options[:directory] || name
-            end
-
-            def create_files
-                template "Gemfile"
-                template "Rakefile"
-                template "Guardfile"
-                template "config.ru"
-                template "config/database.yml"
-                template "lib/main_class.rb", "lib/#{name}.rb"
-                template "lib/main_class/version.rb", "lib/#{name}/version.rb"
-                empty_directory "tmp"
-            end
-
-        end
-    end
-end