lanes 0.0.1

data/lib/lanes/concerns/track_modifications.rb

@@ -0,0 +1,51 @@
+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/concerns/visible_id_identifier.rb

@@ -0,0 +1,53 @@
+module Lanes
+    module Concerns
+
+        # @see ClassMethods
+        module VisibleIdIdentifier
+
+            extend ActiveSupport::Concern
+
+            module InstanceMethods
+
+                # setup the visible id to the next available #{Lanes::SequentialId}
+                # @return [Integer] the assigned ID
+                def assign_visible_id!
+                    self.visible_id = Lanes::SequentialId.next_for( self.class )
+                end
+            end
+
+
+            # ### Visible ID Identifier Concern
+            # This adds the {#has_visible_id} class methods
+            module ClassMethods
+
+                # An auto-incrementing number that's user-visible.
+                # The visible_id is stored as an integer, but a string index is generated for
+                # querying by the sql like operator. The **with_visible_id** scope is available for this purpose
+                #
+                # The next number an also be adjusted by the end-user by setting {Lanes::SequentialId}
+                # so they can set the numbers to start at
+                # a specific point, which is useful for getting Invoice and other
+                # numbers to match up to a legacy system
+                def has_visible_id
+                    include InstanceMethods
+                    validates :visible_id, :presence=>{
+                                  :message=>"ID was not set (should be automatically chosen)"
+                              }
+                    alias_attribute :record_identifier, :visible_id
+                    before_validation :assign_visible_id!, :on=>:create
+
+                    export_scope :with_visible_id, lambda{ | visid |
+                        if visid.to_s =~/%/
+                            where( 'cast(visible_id as varchar) like ?', visid.to_s )
+                        else
+                            where( 'cast(visible_id as varchar) = ?',    visid.to_s )
+                        end
+                    }
+
+                end
+
+            end
+        end
+
+    end
+end

data/lib/lanes/configuration.rb

@@ -0,0 +1,85 @@
+require_relative "concerns/attr_accessor_with_default"
+require 'securerandom'
+
+module Lanes
+
+    class Configuration
+        include Concerns::AttrAccessorWithDefault
+
+        # Since changing a config value inadvertently
+        # can have pretty drastic consequences that might not be
+        # discovered immediately, we log each time a value is changed
+        def self.config_option( name, default, options={} )
+            define_method( "#{name}=" ) do | value |
+                old_value = self.send( name )
+                if old_value && Lanes.logger && !options[:silent]
+                    Lanes.logger.info "Config option #{name} changed from '#{old_value.inspect}' to '#{value.inspect}'"
+                end
+                instance_variable_set( "@#{name}", value )
+                if @observers.has_key?(name)
+                    @observers[name].each{ |cb| cb.call(value, old_value) }
+                end
+            end
+            attr_reader_with_default(name, default)
+        end
+
+        def initialize
+            @observers=Hash.new{ |hash,key| hash[key] = Array.new }
+        end
+
+        def on_change(config, &block)
+            @observers[config.to_sym] << block
+        end
+
+        def get(config, &block)
+            value = self.send(config.to_sym)
+            if block
+                on_change(config,&block)
+                block.call( value, value )
+            end
+            value
+        end
+
+    end
+
+    class DefaultConfiguration < Configuration
+
+        # Since the Configuration class is essentially a singleton,
+        # we don't care about AttrReaderWithDefault sharing values between instances
+        # Therefore all the values are given directly and not enclosed in Procs/lambdas.
+
+        # Database tables will have this prefix applied to them
+        config_option :table_prefix, ''
+
+        config_option :debug_assets, false
+        config_option :default_javascript_tag_options, {}
+
+        config_option :environment, (ENV['RACK_ENV'] || 'development').to_sym
+        # The secret key to use for session cookies.
+        config_option :session_secret_key_base,  '1234', silent: true
+        config_option :redis, { path: "/tmp/redis.sock" }
+        config_option :pubsub_key, nil
+        config_option :pubsub_host, nil
+        config_option :pubsub_timeout, 10
+
+        config_option :es6_transpiler_path, '6to5'
+        config_option :es6_transpiler_options, '-t '
+        config_option :app_title, "Lanes Test"
+
+        config_option :mounted_at, ''
+
+        config_option :specs_root, Pathname.getwd
+    end
+
+    class << self
+        @@config = DefaultConfiguration.new
+        def config
+            @@config
+        end
+
+        def configure
+            yield(@@config)
+        end
+    end
+
+end

data/lib/lanes/db/migration_helpers.rb

@@ -0,0 +1,178 @@
+require 'lanes/configuration'
+
+module Lanes
+
+    module DB
+
+        module TableFields
+
+            def hip_code_identifier
+                column( :code, :string,  :null=>false )
+                hip_extra_indexes['code'] = {}
+            end
+
+            def hip_visible_id
+                column( :visible_id, :integer,  :null=>false )
+                hip_extra_indexes['visible_id'] = {
+                    function: 'CAST(visible_id AS VARCHAR)'
+                }
+            end
+
+            # track modifications
+            def hip_track_modifications( create_only: false )
+                column( :created_at, :datetime,   :null=>false )
+                column( :created_by_id, :integer, :null=>false )
+                unless create_only
+                    column( :updated_at, :datetime,   :null=>false )
+                    column( :updated_by_id, :integer, :null=>false )
+                end
+            end
+
+            def hip_currency( names, options )
+                options[ :precision ] ||= 15
+                options[ :scale ]     ||= 2
+                column( names, :decimal, options )
+            end
+
+            # An hip_reference combines a belongs_to / has_one column
+            # with a postgresql foreign key reference.
+            def hip_reference( to_table, *args )
+                options = args.extract_options!
+
+                options[:column] ||= to_table.to_s + '_id'
+
+                column( options[:column], :integer, :null=>options[:null] || false )
+                to_table = options[:to_table] if options.has_key? :to_table
+
+                if options[:single]
+                    to_table = to_table.to_s.pluralize
+                end
+                hip_foreign_keys[ to_table.to_sym ] = options
+            end
+
+            def hip_foreign_keys
+                @hip_foreign_keys ||= {}
+            end
+
+            def hip_extra_indexes
+                @hip_extra_indexs ||= {}
+            end
+        end
+
+        module MigrationMethods
+
+            def create_hip_table(table_name, *args, &block)
+                definition = nil
+                create_table( Lanes.config.table_prefix + table_name, *args ) do | td |
+                    # Thanks for the trick from the Foreigner gem!
+                    # in connection_adapters/abstract/schema_statements
+                    definition = td
+                    block.call(td) unless block.nil?
+                end
+                definition.hip_foreign_keys.each do |to_table, options |
+                    hip_add_foreign_key( table_name, to_table, options )
+                end
+                definition.hip_extra_indexes.each do | index_column, options |
+                    hip_add_index( table_name, index_column, options )
+                end
+            end
+
+            def hip_add_index( table_name, columns, options={} )
+                table_name = Lanes.config.table_prefix + table_name.to_s
+                if options[:function]
+                    unique = options[:unique] ? 'unique' : ''
+                    name   = table_name + 'indx_' + columns
+                    execute( "create #{unique} index #{name} on #{table_name}(#{options[:function]})" )
+                else
+                    add_index( table_name, columns, options  )
+                end
+            end
+
+            def hip_add_foreign_key( table_name, to_table, options = {} )
+                from_table = Lanes.config.table_prefix + table_name.to_s
+                to_table   = Lanes.config.table_prefix + to_table.to_s
+                # table_name #from_table = Lanes.config.table_prefix + table_name
+                column  = options[:column] || "#{to_table.to_s.singularize}_id"
+                foreign_key_name = options.key?(:name) ? options[:name].to_s : "#{from_table}_#{column}_fk"
+
+                primary_key = options[:primary_key] || "id"
+                dependency = case options[:dependent]
+                             when :nullify then "ON DELETE SET NULL"
+                             when :delete  then "ON DELETE CASCADE"
+                             when :restrict then "ON DELETE RESTRICT"
+                             else ""
+                             end
+                sql = "ALTER TABLE #{quote_table_name(from_table)} " +
+                "ADD CONSTRAINT #{quote_column_name(foreign_key_name)} " +
+                "FOREIGN KEY (#{quote_column_name(column)}) " +
+                "REFERENCES #{quote_table_name( to_table )}(#{primary_key})"
+                sql << " #{dependency}" if dependency.present?
+                sql << " #{options[:options]}" if options[:options]
+
+                execute(sql)
+            end
+
+            def drop_hip_table( table_name, *args )
+                drop_table( Lanes.config.table_prefix + table_name )
+            end
+
+            def remove_hip_index( table_name, column )
+                remove_index( Lanes.config.table_prefix + table_name, column )
+            end
+
+        end
+
+        module CommandRecorder
+            def create_hip_table(*args)
+                record(:create_hip_table, args)
+            end
+
+            def drop_hip_table(*args)
+                record(:drop_hip_table, args)
+            end
+
+            def invert_create_hip_table(args)
+                from_table, to_table, add_options = *args
+                add_options ||= {}
+                if add_options[:name]
+                    options = {name: add_options[:name]}
+                elsif add_options[:column]
+                    options = {column: add_options[:column]}
+                else
+                    options = to_table
+                end
+                [:drop_hip_table, [from_table, options]]
+            end
+
+            def hip_add_index(*args)
+                record(:hip_add_index,args)
+            end
+            def invert_hip_add_index(args)
+                table, column = *args
+                [:remove_hip_index, [table, column]]
+            end
+
+        end
+
+    end
+
+end
+
+
+class ActiveRecord::Migration
+    def hip_prefix
+        Lanes.config.table_prefix
+    end
+end
+
+ActiveRecord::Migration::CommandRecorder.class_eval do
+    include Lanes::DB::CommandRecorder
+end
+
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+    include Lanes::DB::MigrationMethods
+end
+
+ActiveRecord::ConnectionAdapters::TableDefinition.class_eval do
+    include Lanes::DB::TableFields
+end

data/lib/lanes/db/migrations.rb

@@ -0,0 +1,13 @@
+require 'pathname'
+
+module Lanes
+    module DB
+        module Migrations
+            # The `paths` array is an extension point for other
+            mattr_accessor :paths
+            self.paths = [
+              Pathname.new(__FILE__).dirname.join("../../../db/migrate").realpath
+            ]
+        end
+    end
+end

data/lib/lanes/db/seed.rb

@@ -0,0 +1,27 @@
+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/db.rb

@@ -0,0 +1,86 @@
+require_relative 'db/seed'
+
+module Lanes
+
+    module DB
+        extend self
+
+        attr_accessor(:config_file)
+
+        def establish_connection( env = ENV['RAILS_ENV'] || 'development')
+            file = config_file || 'config/database.yml'
+            config = YAML::load( IO.read( file ) )
+            ::ActiveRecord::Base.configurations = config
+            self.connect( ::ActiveRecord::Base.configurations[ env ] )
+        end
+
+        def connect( configuration )
+            ::ActiveRecord::Base.establish_connection( configuration )
+        end
+
+        def migration_exists?( file_name ) #:nodoc:
+            Dir.glob("#{migrations_dir}/[0-9]*_*.rb").grep(/\d+_#{file_name}.rb$/).first
+        end
+
+        def load_seed
+            load Pathname.new(__FILE__).dirname.join("../../db/seed.rb")
+            Seed.execute!
+        end
+
+        def configure_rake_environment
+            ActiveRecord::Tasks::DatabaseTasks.seed_loader = Lanes::DB
+            env = ENV['RAILS_ENV'] || 'development'
+            Lanes::DB.config_file ||= 'config/database.yml'
+            ENV['SCHEMA'] ||= 'db/schema.sql'
+            ENV['DB_STRUCTURE'] ||= 'db/schema.sql'
+            ActiveRecord::Base.schema_format = :sql
+            Lanes::DB.establish_connection( env )
+            ActiveRecord::Tasks::DatabaseTasks.database_configuration = ActiveRecord::Base.configurations
+            ActiveRecord::Tasks::DatabaseTasks.env = 'test'
+            ActiveRecord::Tasks::DatabaseTasks.migrations_paths = 'db/migrate'
+            ActiveRecord::Tasks::DatabaseTasks.current_config( :config => ActiveRecord::Base.configurations[ env ] )
+        end
+
+        def create_migration( migration_name )
+            STDERR.puts "Migration #{migration_name} already exists!" and return false if migration_exists?( migration_name )
+            migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S")
+            migration_file = File.join(migrations_dir, "#{migration_number}_#{migration_name}.rb")
+            migration_class = migration_name.split("_").map(&:capitalize).join
+            File.open(migration_file, 'w') do |file|
+                file.write <<-MIGRATION.strip_heredoc
+            class #{migration_class} < ActiveRecord::Migration
+                def change
+                end
+            end
+            MIGRATION
+            end
+        end
+
+        def migrate(version = nil)
+            silence_activerecord do
+                migration_version = version ? version.to_i : version
+                ::ActiveRecord::Migrator.migrate( migrations_dir, migration_version )
+            end
+        end
+
+        def rollback(step = nil)
+            silence_activerecord do
+                migration_step = step ? step.to_i : 1
+                ::ActiveRecord::Migrator.rollback(migrations_dir, migration_step)
+            end
+        end
+
+        private
+
+        def migrations_dir
+            ::ActiveRecord::Migrator.migrations_paths.first
+        end
+
+        def silence_activerecord(&block)
+            old_logger = ::ActiveRecord::Base.logger
+            ::ActiveRecord::Base.logger = nil
+            yield if block_given?
+            ::ActiveRecord::Base.logger = old_logger
+        end
+    end
+end

data/lib/lanes/environment.rb

@@ -0,0 +1,19 @@
+module Lanes
+
+    class Environment
+        def test?
+            Lanes.config.environment == :test
+        end
+        def development?
+            Lanes.config.environment == :development
+        end
+        def production?
+            Lanes.config.environment == :production
+        end
+    end
+
+    # @return [Environment]
+    def self.env
+        @environment ||= Environment.new
+    end
+end

data/lib/lanes/extension.rb

@@ -0,0 +1,72 @@
+module Lanes
+
+    class Extension
+
+        def initialize(*args)
+        end
+
+        class_attribute :identifier
+
+        # [String] The path for including the extension in the asset pipeline
+        class_attribute :logical_path
+
+
+        # [String] The directory that holds the the root of the asset pipeline
+        class_attribute :asset_path
+
+        class_attribute :before
+        class_attribute :after
+
+        def bootstrap_data(view)
+            {}
+        end
+
+        class << self
+
+            def load_after(extension)
+                self.after = extension
+            end
+
+            def load_before(extension)
+                self.before = extension
+            end
+
+            def active
+                unmapped = self.descendants
+                mapped   = []
+                while unmapped.any?
+                    mapped_count = mapped.length
+                    unmapped.each do | ext |
+                        if !ext.before && !ext.after
+                            mapped.push(ext)
+                        end
+                        if ext.before && (position = mapped.find_index(ext.before))
+                            mapped.insert(position, ext)
+                        end
+                        if ext.after && (position = mapped.find_index(ext.after))
+                            mapped.insert(position+1, ext)
+                        end
+                    end
+                    if mapped_count == mapped.length # we failed to add any extensions
+                        Lanes.logger.info "Conflicting load directives.  Some extensions will not be available"
+                    end
+                    unmapped -= mapped
+                end
+                mapped
+            end
+
+            def each(config={})
+                self.active.each{ |klass| yield klass.new(config) }
+            end
+
+            def bootstrap_data(env)
+                data = { 'roles' => Lanes::Access::Role.all_available }
+                each do | ext |
+                    data[ext.identifier] = data.bootstrap_data(env)
+                end
+                return data
+            end
+        end
+
+    end
+end

data/lib/lanes/generators/app/Gemfile

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

data/lib/lanes/generators/app/Guardfile

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

data/lib/lanes/generators/app/Rakefile

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

data/lib/lanes/generators/app/config/database.yml

@@ -0,0 +1,9 @@
+development:
+  adapter: postgresql
+  database: <%= name %>_dev
+  host: /tmp
+
+test:
+  adapter: postgresql
+  database: <%= name %>_test
+  host: /tmp

data/lib/lanes/generators/app/config.ru

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

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

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

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

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

data/lib/lanes/generators/app.rb

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