lanes 0.0.1

data/lib/lanes/guard_tasks.rb

@@ -0,0 +1,44 @@
+require_relative "../lanes"
+require 'guard'
+
+module Lanes
+    module GuardTasks
+
+        class CustomMatchers
+            attr_reader :client_matches, :server_matches
+
+            def client(&block)
+                @client_matches = block
+            end
+            def server(&block)
+                @server_matches = block
+            end
+        end
+
+        def self.run(dsl, options, &block)
+            app_name = options[:name] || Pathname.getwd.basename.to_s
+            matchers = CustomMatchers.new
+            yield matchers
+
+            jasmine_options = {
+                server_mount: '/spec', server_env: 'test', server: :puma, spec_dir: 'spec/client', debug: false
+            }
+
+            dsl.guard :jasmine, jasmine_options do
+                dsl.watch(%r{^client/javascripts/(.+?)\.(js|coffee)$}){ |m| "spec/client/#{m[1]}_spec.#{m[2]}" }
+                dsl.watch(%r{^spec/client/.*(?:_s|S)pec\.coffee$})
+                matchers.client_matches.call if matchers.client_matches
+            end
+
+            dsl.guard :minitest, :all_on_start => true do
+                dsl.watch(%r{^spec/spec_helper\.rb}) { 'test' }
+                dsl.watch(%r{^spec/.+_spec\.rb})
+                dsl.watch(%r{^spec/fixtures/#{app_name}/(.+)s\.yml})   { |m| "spec/#{m[1]}_spec.rb" }
+                dsl.watch(%r{^lib/#{app_name}/(.+)\.rb})               { |m| "spec/#{m[1]}_spec.rb" }
+                matchers.server_matches.call if matchers.server_matches
+            end
+
+        end
+
+    end
+end

data/lib/lanes/logger.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+require 'logger'
+
+module Lanes
+
+    class << self
+        def logger
+            @logger ||= (
+              if defined?(::Rails)
+                  Rails.logger
+              else
+                  Logger.new(STDOUT)
+              end
+            )
+        end
+
+        def logger=( logger )
+            @logger = logger
+        end
+
+        def silence_logs( &block )
+            old_logger = Lanes.logger
+            begin
+                Lanes.logger=Logger.new( StringIO.new )
+                yield
+            ensure
+                Lanes.logger=old_logger
+            end
+        end
+
+        def logger_debug( output )
+            logger.debug '⚡ '*40
+            logger.debug '⚡ ' + output
+            logger.debug '⚡ '*40
+        end
+    end
+end

data/lib/lanes/model.rb

@@ -0,0 +1,26 @@
+require_relative 'concerns/all'
+
+module Lanes
+
+
+    class Model < ::ActiveRecord::Base
+        self.abstract_class = true
+
+        include Concerns::PubSub
+        include Concerns::ApiAttributeAccess
+        include Concerns::LockedFields
+        include Concerns::CodeIdentifier
+        include Concerns::RandomHashCode
+        include Concerns::VisibleIdIdentifier
+        include Concerns::ImmutableModel
+        include Concerns::ExportMethods
+        include Concerns::ExportScope
+        include Concerns::ExportAssociations
+        include Concerns::ExportJoinTables
+        include Concerns::SanitizeApiData
+        include Concerns::AssociationExtensions
+        include Concerns::ApiPath
+
+    end
+
+end

data/lib/lanes/numbers.rb

@@ -0,0 +1,72 @@
+# * Utility methods that manipulate Numbers
+
+module Lanes
+    module Numbers
+        # Document the responsibility of the class
+        #
+        # == Heading
+        #
+        # Use headings to break up descriptions
+        #
+        # == Formatting
+        #
+        # Embody +parameters+ or +options+ in Teletype Text tags. You can also use
+        # *bold* or *italics* but must use HTML tags for <b>multiple words</b>,
+        # <i>like this</i> and <tt>like this</tt>.
+        # - See more at: http://blog.firsthand.ca/2010/09/ruby-rdoc-example.html#sthash.q9Jkcjrl.dpuf
+
+
+        # ### PercNum
+        #
+        #
+        # A "percnum" is a Stockor invention *(or abomination, depending on your POV)*.
+        # It's a string that contains a number and an optional percent sign.
+        # If the percent sign is present, the number is treated as a percentage.
+        # If desired the user may also input negative numbers which will invert the sense of the method.
+        #
+        # It's intended to be a user-friendly method to provide one input box for "discount" or "surcharge",
+        # and allow the user to input either a flat amount such as 4.50, or a percentage like 20%
+        #
+        class PercNum
+            # @param perc_or_num [BigDecimal,String, Integer] any value that BigDecimal will accept
+            def initialize( perc_or_num )
+                @is_perc    = !! perc_or_num.to_s.match( /\%\s*$/ )
+                @right_side = BigDecimal.new( perc_or_num, 5 )
+                if is_percentage?
+                    @right_side *= 0.01
+                end
+            end
+
+            # Adds the PercNum to the specified amount.
+            # @param amount[BigDecimal] the amount that should be added to the PercNum
+            # @return [BigDecimal] The result of either adding (non percent) or multiplying by (percent) the amount
+            # @example
+            #     PercNum.new( '23.42' ).credit_to(  33 ).to_s  #=> '56.42'
+            #     PercNum.new( '25%'   ).credit_to( 100 ).to_s  #=> '125.0'
+            def credit_to( amount )
+                is_percentage? ? ( 1 + @right_side ) * amount : amount += @right_side
+            end
+
+            # Subtracts the PercNum to the specified amount.
+            # @param amount[BigDecimal] the amount that should be added to the PercNum
+            # @return [BigDecimal] The result of either adding (non percent) or multiplying by (percent) the amount
+            # @example
+            #     PercNum.new( '23.42' ).debit_from( 42.42 ).to_s  #=> '19.00'
+            #     PercNum.new( '25%'   ).debit_from( 100   ).to_s  #=> '75.0'
+            def debit_from( amount )
+                is_percentage? ? ( 1 - @right_side ) * amount : amount -= @right_side
+            end
+
+            ## If PercNum was initialized with a blank string
+            def present?
+                ! @right_side.zero?
+            end
+
+            # Is the PercNum percentage based or absolute
+            def is_percentage?
+                @is_perc
+            end
+        end
+
+    end
+end

data/lib/lanes/rails_engine.rb

@@ -0,0 +1,5 @@
+module Lanes::Core
+    class RailsEngine < Rails::Engine
+        config.autoload_paths += Dir["#{config.root}/lib/**/"]
+    end
+end

data/lib/lanes/screens.rb

@@ -0,0 +1,126 @@
+require 'yaml'
+
+module Lanes
+
+    module Screens
+        class << self
+
+            def each_directory
+                root = Pathname.new(__FILE__).dirname.join('../../assets/screens')
+                root.each_child do | path  |
+                    yield path if path.directory?
+                end
+            end
+
+            def assets_for_directory(directory)
+                path = "skr/screens/#{directory.basename}"
+                assets = []
+                unless Pathname.glob([ directory.join('*.js'), directory.join('*.coffee')] ).empty?
+                    assets << "#{path}.js"
+                end
+                unless Pathname.glob([ directory.join('*.css'), directory.join('*.scss')] ).empty?
+                    assets << "#{path}.css"
+                end
+                assets
+            end
+
+            # def groups(sprockets)
+            #     groups = []
+            #     each_definition(sprockets) do | spec |
+            #         unless groups.detect{ |group| group['id'] == spec.group_id }
+            #             groups << spec.group_definition
+            #         end
+            #         groups
+            #     end
+            # end
+
+            # def each_definition(sprockets)
+            #     ScreenDefinition.each(sprockets) do | definition |
+            #         spec = definition.specification
+            #         spec['files'] = definition.asset_file_names.map{ |file| "/assets/#{file}" }
+            #         yield spec
+            #     end
+            # end
+        end
+
+        class Group
+            include Concerns::AttrAccessorWithDefault
+
+            attr_accessor_with_default :identifier
+            attr_accessor_with_default :title
+            attr_accessor_with_default :description
+            attr_accessor_with_default :icon
+
+            def self.each(config)
+                self.descendants.each{ |klass| yield klass.new(config) }
+            end
+
+            def initialize(sprockets)
+                @sprockets=sprockets
+            end
+
+            def to_json
+                Oj.dump({
+                    id: identifier,
+                    title: title,
+                    description: description,
+                    icon: icon
+                }, mode: :compat)
+            end
+        end
+
+        class Definition
+            include Concerns::AttrAccessorWithDefault
+
+            attr_accessor_with_default :identifier
+            attr_accessor_with_default :title
+            attr_accessor_with_default :description
+            attr_accessor_with_default :icon
+            attr_accessor_with_default :group_id
+            attr_accessor_with_default :view_class
+            attr_accessor_with_default :model_class
+            attr_accessor_with_default :files
+
+            def self.each(config)
+                self.descendants.each{ |klass| yield klass.new(config) }
+            end
+
+            def initialize(sprockets)
+                @sprockets=sprockets
+            end
+
+            def to_json
+                Oj.dump({
+                    id:    identifier,
+                    title: title,
+                    icon:  icon,
+                    model: model_class,
+                    view:  view_class,
+                    files: files,
+                    group_id: group_id,
+                    description: description
+                }, mode: :compat)
+            end
+        end
+
+        class SystemGroup < Group
+            identifier  "system-settings"
+            title       "System Settings"
+            description "Modify system settings"
+            icon        "icon-wrench"
+        end
+
+        class UserMaintScreen < Definition
+            identifier  "user-maintenance"
+            title       "User Maintenance"
+            description "Add/Remove/Modify User Accounts"
+            icon        "icon-group"
+            group_id    "system-settings"
+            model_class "User"
+            view_class  "UserManagement"
+            files       ['/assets/user-management.js','/assets/user-management.css']
+        end
+
+    end
+
+end

data/lib/lanes/spec_asset_expander.rb

@@ -0,0 +1,43 @@
+module Lanes
+    class SpecAssetExpander
+
+        def expand(src_dir, src_path)
+            pathname = src_path.gsub(/^\/?assets\//, '').gsub(/\.js$/, '')
+
+            asset_bundle.assets(pathname).flat_map { |asset|
+                "/#{asset.gsub(/^\//, '')}?body=true"
+            }
+        end
+
+        private
+
+        def asset_bundle
+            return AssetBundle.new
+        end
+
+        class AssetBundle
+            def assets(pathname)
+                context.get_original_assets(pathname)
+            end
+
+            private
+
+            def context
+                @context ||= ActionView::Base.new.extend(GetOriginalAssetsHelper)
+            end
+
+            module GetOriginalAssetsHelper
+                def get_original_assets(pathname)
+                    assets_environment.find_asset(pathname).to_a.map do |processed_asset|
+                        case processed_asset.content_type
+                        when "text/css"
+                            path_to_stylesheet(processed_asset.logical_path, debug: true)
+                        when "application/javascript"
+                            path_to_javascript(processed_asset.logical_path, debug: true)
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/lanes/strings.rb

@@ -0,0 +1,56 @@
+module Lanes
+
+    module Strings
+
+        # list of characters that should not be used
+        BAD_RAND_CHARS  = %w{ B 8 o O 0 i l I 1 }
+
+        # characters that should be randomly chosen from
+        RAND_CHARS = ( ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a ) - BAD_RAND_CHARS
+
+        # Generates a random string without using commonly confused numbers and letters.
+        # It's intended for use in situations where the code will have to be
+        # read and re-entered later.
+        #
+        # The characters in BAD_RAND_CHARS are avoided since they can be confused with one another:
+        # @return [String] a random string <length> characters long.
+        def self.random( length = 12 )
+            1.upto(length).each_with_object(''){|i,s| s << RAND_CHARS[ rand(RAND_CHARS.length) ] }
+        end
+
+        # Attempts to shorten a string while keeping it somewhat
+        # like it's original self.
+        # Useful for suggesting a code for a given entity name.
+        # @param string [String] the string to shorten.
+        # @param length [Integer] how long the returned code should be
+        # @param padding [String] What to pad the code with if it is shorter than length.  False indicates no padding should be performed
+        # @return [String] a shortened version of the name with:
+        #  * Upper cased
+        #  * Spaces stripped
+        #  * Made up of a proportional number of chars from each word
+        # #### Examples:
+        #     Lanes::Strings.to_code_identifier('General Acme Corp')       #=> 'GENACMCORP'
+        #     Lanes::Strings.code_identifier('General I B', padding:false) #=> 'GENERALIB' *(no trailing X)*
+        #     Lanes::Strings.to_code_identifier('Top Cat', maxlen: 5 )     #=> 'TOCAT'
+        def self.code_identifier( string, length:10, padding: 'X' )
+            stripped = string.gsub(/\W/, '').upcase
+            if stripped.length < length
+                return padding.present? ? stripped.ljust( length, padding ) : stripped
+            end
+            result = ''
+            words = string.gsub(/[^\w\s-]/,'').split(/\s+|-|_/)
+            0.upto(words.length + 1).each_with_index do | attempt_num |
+                remainder = length
+                result = ''
+                string = words.each_with_index do | word, index |
+                    chars = ( remainder / (words.length-index) + attempt_num )
+                    result << word[0...chars]
+                    remainder = length - result.length
+                end
+                break if result.length >= length
+            end
+            result[0...length].upcase
+        end
+
+    end
+end

data/lib/lanes/user.rb

@@ -0,0 +1,127 @@
+module Lanes
+
+    class User < Lanes::Model
+        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 "concerns/track_modifications"
+
+    # We can only use the TrackModifications concern after the User model is defined
+    Model.send(:include, Concerns::TrackModifications )
+
+end

data/lib/lanes/validators/all.rb

@@ -0,0 +1,2 @@
+require_relative "set"
+require_relative "email"

data/lib/lanes/validators/email.rb

@@ -0,0 +1,17 @@
+# A custom validator "email".
+# Doesn't really validate an email completely
+# It simply asserts that the email string has one (and only one)
+# @ (at symbol). This is mainly
+# to give user feedback and not to assert the e-mail validity.
+
+class EmailValidator < ActiveModel::EachValidator
+
+    # Regex originated from the Devise gem
+    REGEX = /\A[^@]+@([^@\.]+\.)+[^@\.]+\z/
+
+    def validate_each( rec, attr, value)
+        unless value.present? && value.match( REGEX )
+            rec.errors.add attr, options[:message] || 'does not appear to be a valid email'
+        end
+    end
+end

data/lib/lanes/validators/set.rb

@@ -0,0 +1,18 @@
+# A custom validator "set".  It's similar to :presence validator
+# Unlike :presence, :set doesn't care whether the associated record is valid or not, just that it is present
+# Also unlike :presence, it only works on belongs_to
+class SetValidator < ActiveModel::EachValidator
+
+    def validate_each( record, attribute, value)
+        association = record.class.reflect_on_association( attribute )
+
+        if association.nil? || !association.belongs_to?
+            raise ArgumentError, "Cannot validate existence on #{record.class} #{attribute}, not a :belongs_to association"
+        end
+
+        if record.send( attribute ).nil?
+            record.errors.add( attribute, "is not set")
+        end
+
+    end
+end

data/lib/lanes/version.rb

@@ -0,0 +1,5 @@
+module Lanes
+
+    VERSION = "0.0.1"
+
+end

data/lib/lanes.rb

@@ -0,0 +1,22 @@
+require 'active_record'
+
+require_relative "lanes/version"
+require_relative "lanes/logger"
+require_relative "lanes/environment"
+require_relative "lanes/configuration"
+if defined?(::Rails)
+    require_relative "lanes/rails_engine"
+end
+require_relative "lanes/db"
+
+require_relative "lanes/strings"
+require_relative "lanes/numbers"
+require_relative "lanes/concerns/all"
+require_relative "lanes/validators/all"
+require_relative "lanes/model"
+require_relative "lanes/user"
+
+require_relative "lanes/access"
+
+require_relative "lanes/extension"
+require_relative "lanes/screens"

data/npm-build/README

@@ -0,0 +1 @@
+no comment

data/npm-build/compile.coffee

@@ -0,0 +1,15 @@
+#!/usr/bin/env coffee
+
+browserify = require 'browserify'
+fs         = require 'fs'
+path       = require 'path'
+#exposify   = require 'exposify'
+
+# configure what we want to expose
+#exposify.config = { jquery: 'jQuery', underscore: '_' }
+
+browserify({ debug: true })
+#    .transform(exposify)
+    .require(require.resolve('./template.js'), { entry: true })
+    .bundle()
+    .pipe(fs.createWriteStream(path.join(__dirname, '../assets/javascripts/vendor/packaged.js'), 'utf8'))