lanes 0.0.1

data/client/stylesheets/vendor/bootstrap.scss

@@ -0,0 +1,69 @@
+// Core variables and mixins
+
+$zindex-navbar:            1;
+$zindex-dropdown:          30;
+$zindex-popover:           30;
+$zindex-tooltip:           10;
+$zindex-navbar-fixed:      1;
+$zindex-modal-background:  25;
+$zindex-modal:             26;
+$zindex-tooltip:           31;
+$grid-gutter-width: 10px;
+$popover-max-width: 320px;
+
+@import "bootstrap/variables";
+@import "bootstrap/mixins";
+
+.lanes{
+
+  // Reset and dependencies
+  @import "bootstrap/normalize";
+  @import "bootstrap/print";
+  /* @import "bootstrap/glyphicons"; */
+
+  // Core CSS
+  @import "bootstrap/scaffolding";
+  @import "bootstrap/type";
+  @import "bootstrap/code";
+  @import "bootstrap-custom-grid";
+  /* @import "bootstrap/grid"; */
+  @import "bootstrap/tables";
+  @import "bootstrap/forms";
+  @import "bootstrap/buttons";
+
+  // Components
+  @import "bootstrap/component-animations";
+  @import "bootstrap/dropdowns";
+  @import "bootstrap/button-groups";
+  @import "bootstrap/input-groups";
+  @import "bootstrap/navs";
+  @import "bootstrap/navbar";
+  @import "bootstrap/breadcrumbs";
+  @import "bootstrap/pagination";
+  @import "bootstrap/pager";
+  @import "bootstrap/labels";
+  @import "bootstrap/badges";
+  @import "bootstrap/jumbotron";
+  @import "bootstrap/thumbnails";
+  @import "bootstrap/alerts";
+  @import "bootstrap/progress-bars";
+  @import "bootstrap/media";
+  @import "bootstrap/list-group";
+  @import "bootstrap/panels";
+  @import "bootstrap/responsive-embed";
+  @import "bootstrap/wells";
+  @import "bootstrap/close";
+
+  // Components w/ JavaScript
+  @import "bootstrap-custom-modals";
+
+  /* @import "bootstrap/modals"; */
+
+  @import "bootstrap/tooltip";
+  @import "bootstrap/popovers";
+  /* @import "bootstrap/carousel"; */
+
+  // Utility classes
+  @import "bootstrap/utilities";
+  @import "bootstrap/responsive-utilities";
+}

data/client/stylesheets/vendor/dataTables.scss

@@ -0,0 +1,4 @@
+.lanes {
+//  @import "dataTables/jquery.dataTables";
+  @import "dataTables/dataTables.scroller";
+}

data/config/database.yml

@@ -0,0 +1,9 @@
+development:
+  adapter: postgresql
+  database: lanes_dev
+  host: /tmp
+
+test:
+  adapter: postgresql
+  database: lanes_test
+  host: /tmp

data/config/puma.rb

@@ -0,0 +1,7 @@
+#daemonize
+
+workers    1 # should be same number of your CPU core
+threads    1, 6
+
+pidfile    "tmp/lanes.pid"
+#stdout_redirect 'log/lanes.log', 'log/lanes-error.log', true

data/config.ru

@@ -0,0 +1,4 @@
+require 'bundler'
+Bundler.require
+require 'lanes/api'
+run Lanes::API::Root

data/db/migrate/20140615031600_create_hip_users.rb

@@ -0,0 +1,17 @@
+require 'lanes/db/migration_helpers'
+
+class CreateHipUsers < ActiveRecord::Migration
+    def change
+        create_hip_table "users" do | t |
+            t.string :login, :name, :email,  null: false
+            t.text   :notes
+            t.string :password_digest, null: false
+            t.string  :role_names,   array: true, null:false, default: []
+            t.json    :options,      null: false, default:  {}
+            t.hip_track_modifications
+        end
+
+        hip_add_index  :users, :role_names, using: 'gin'
+
+    end
+end

data/db/seed.rb

@@ -0,0 +1,37 @@
+Lanes::DB::Seed.add do
+
+    # This could totes be better written
+
+    unless Lanes::User.exists?(1)
+        u = Lanes::User.new( name: "Administrator Tester", email: "admin-test@stockor.org",
+          login: "admin", role_names: ['administrator'] )
+        u.id = 1
+        u.password = "password"
+        u.save!
+    end
+
+    unless Lanes::User.exists?(2)
+        u = Lanes::User.new( name: "Accounting Tester", email: "accounting-test@stockor.org",
+          login: "accounting", role_names: ['accounting'] )
+        u.id = 2
+        u.password = "password"
+        u.save!
+    end
+
+    unless Lanes::User.exists?(3)
+        u = Lanes::User.new( name: "Customer Support Tester", email: "support-test@stockor.org",
+          login: "support", role_names: ['customer_support'] )
+        u.id = 3
+        u.password = "password"
+        u.save!
+    end
+
+    unless Lanes::User.exists?(4)
+        u = Lanes::User.new( name: "Purchasing Tester", email: "purchasing-test@stockor.org",
+          login: "purchasing", role_names: ['purchasing'] )
+        u.id = 4
+        u.password = "password"
+        u.save!
+    end
+
+end

data/foo/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem "lanes", "~>0.2"
+
+gemspec

data/foo/Guardfile

@@ -0,0 +1,13 @@
+require "lanes/guard_tasks"
+
+Lanes::GuardTasks.run(self, name: "foo") do | tests |
+
+    tests.client do
+
+    end
+
+    tests.server do
+
+    end
+
+end

data/foo/foo/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem "lanes", "~>0.2"
+
+gemspec

data/foo/foo/lib/foo.rb

@@ -0,0 +1,7 @@
+require 'lanes'
+
+# The main entry point for Foo
+class Foo
+
+
+end

data/foo/lib/foo/version.rb

@@ -0,0 +1,3 @@
+module Foo
+    VERSION=0.1
+end

data/foo/lib/foo.rb

@@ -0,0 +1,8 @@
+require "lanes"
+require "foo/version.rb"
+
+# The main namespace for Foo
+module Foo
+
+
+end

data/lanes.gemspec

@@ -0,0 +1,54 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lanes/version'
+
+Gem::Specification.new do |spec|
+
+    spec.name          = "lanes"
+    spec.version       = Lanes::VERSION
+    spec.authors       = ["Nathan Stitt"]
+    spec.email         = ["nathan@argosity.com"]
+
+    spec.summary       = %q{Stockor Core contains the models for the Stockor ERP system}
+    spec.description   = %q{Stockor Core contains the ActiveRecord models and business logic for the Stockor ERP system}
+
+    spec.homepage      = "http://stockor.org/"
+    spec.license       = "MIT"
+
+    spec.files         = `git ls-files`.split($/)
+    spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+    spec.test_files    = spec.files.grep(%r{^test/})
+    spec.require_paths = ["lib"]
+
+    spec.required_ruby_version = ">= 2.0"
+
+    spec.add_dependency "activerecord",           "~> 4.1"
+    spec.add_dependency "pg",                     "~> 0.17"
+    spec.add_dependency "sinatra",                "~> 1.4"
+    spec.add_dependency "bcrypt-ruby",            "~> 3.1"
+    spec.add_dependency "oj",                     "~> 2.1"
+    spec.add_dependency "message_bus",            "~> 1.0"
+    spec.add_dependency "rack_csrf",              "~> 2.5"
+    spec.add_dependency "sprockets",              "~> 2.0"
+    spec.add_dependency "coffee-script",          "~> 2.3"
+    spec.add_dependency "execjs",                 "~> 2.2"
+    spec.add_dependency "thor",                   "~> 0.19"
+
+    spec.add_dependency "sass",                   "~> 3.4"
+    spec.add_dependency "sass-css-importer",      "~> 1.0"
+    spec.add_dependency "sprockets-helpers",      "~> 1.1"
+
+    spec.add_dependency "guard",                  "~> 2.0"
+    spec.add_dependency "hashie",                 "~> 3.3"
+    spec.add_dependency "rack-test",              "~> 0.6"
+    spec.add_dependency "minitest-around",        "~> 0.2"
+    spec.add_dependency "guard-minitest",         "~> 2.3"
+    spec.add_dependency "rake",                   "~> 10.0"
+    spec.add_dependency "jasmine-core",           "~> 2.0"
+
+    spec.add_development_dependency "bundler",    "~> 1.5"
+    spec.add_development_dependency "growl",      "~> 1.0"
+    spec.add_development_dependency "pry-byebug", "~> 2.0"
+
+end

data/lib/generators/lanes/migrations/install_generator.rb

@@ -0,0 +1,42 @@
+require 'lanes/db/migrations'
+
+module Lanes
+
+    module Migrations
+
+        class InstallGenerator < Rails::Generators::Base
+            include Rails::Generators::Migration
+
+            source_root Lanes::DB::Migrations.paths.first
+
+            Lanes::DB::Migrations.paths.slice(1..-1).each do | source_path |
+                source_paths << source_path
+            end
+
+            desc "Install Stockor migrations"
+            def self.next_migration_number(path)
+                unless @prev_migration_nr
+                    @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+                else
+                    @prev_migration_nr += 1
+                end
+                @prev_migration_nr.to_s
+            end
+
+            def copy_migrations
+                Lanes::DB::Migrations.paths.each do | source_path |
+
+                    Pathname.glob( source_path.join('*') ).each do | migration |
+                        from = File.basename( migration )
+                        dest = from.gsub(/^\d+_(.*).rb$/,'\\1.rb')
+                        if self.class.migration_exists?("db/migrate", "#{dest}")
+                            say_status("skipped", "Migration #{dest} already exists")
+                        else
+                            migration_template( from, "db/migrate/#{dest}" )
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/lanes/access/locked_fields.rb

@@ -0,0 +1,43 @@
+module Lanes
+    module Access
+
+        class LockedFields
+
+            @definitions = Hash.new{ |fields,klass|
+                fields[klass] = Hash.new{ |grants,field| grants[field] = [] }
+            }
+            class << self
+
+                # @param klass [Lanes::Model]
+                # @param field [Symbol]
+                # @param access_type [:read, :write]
+                # @return [Array<Role>] Roles that are allowed to access the field.
+                # An empty array indicates that the field is not locked and the Model
+                # should be used for determining access
+                def roles_needed_for(klass, attribute, access_type)
+                    if @definitions.has_key?(klass) && @definitions[klass].has_key?(attribute)
+                        @definitions[klass][attribute].each_with_object([]) do | grant, result |
+                            result.push(grant[:role]) if grant[:only].nil? || grant[:only] == access_type
+                        end
+                    else
+                        []
+                    end
+                end
+
+                # Lock a given class and attribute to a given role
+                # @param klass [Lanes::Model]
+                # @param field [Symbol]
+                # @param only [:read, :write]
+                def lock(klass, field, role, only=nil)
+                    @definitions[klass][field] << { role: role, only: only }
+                end
+
+                def definitions
+                    @definitions
+                end
+            end
+
+        end
+
+    end
+end

data/lib/lanes/access/role.rb

@@ -0,0 +1,58 @@
+# N.B. Keep in sync with js/user-extension/lanes/extensions/user-access/Roles.coffee
+
+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
+                def grant_global_access(klass,types=[:read,:write,:delete])
+                    types = [*types]
+                    descendants.each do | child |
+                        types.each{ |type| child.send(type).push(klass) }
+                    end
+                end
+
+                def inherited(sub)
+                    sub.read = []; sub.write = []; sub.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
+                    descendants.map{ |klass| klass.to_s.demodulize }
+                end
+            end
+        end
+
+    end
+end

data/lib/lanes/access/role_collection.rb

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

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

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

data/lib/lanes/access/user_maint_screen.rb

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

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

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