lanes 0.0.1

data/lib/lanes/api/pub_sub.rb

@@ -0,0 +1,33 @@
+require "oj"
+
+require_relative "updates"
+
+require 'message_bus'
+
+module Lanes
+    module API
+
+        class PubSub
+
+            def self.publish(channel, data)
+                MessageBus.publish channel, data #Oj.dump(data, mode: :compat)
+            end
+
+            def self.initialize
+                # Use OJ - it encodes dates properly as ISO 8601
+                # https://github.com/moment/moment/issues/1407
+                Oj.mimic_JSON()
+                # # Requiring json here seems to stop conflicts when requiring json in other files.
+                begin
+                    require 'json'
+                rescue Exception
+                    # ignore
+                end
+                ::MessageBus.redis_config = Lanes.config.redis
+                Updates.relay!
+            end
+
+        end
+
+    end
+end

data/lib/lanes/api/request_wrapper.rb

@@ -0,0 +1,42 @@
+module Sinatra
+
+    module RequestWrapper
+
+        def wrap_request(model, params, parent_attribute)
+
+            authentication = Lanes::API::AuthenticationProvider.new(
+              request_type: request.request_method,
+              session:      session,
+              params:       params
+            )
+
+            unless authentication.allowed_access_to?(model)
+                halt( 401, Oj.dump({
+                    success:false, errors: {user: "Access Denied"}, message: authentication.error_message
+                }))
+            end
+            ::Lanes::User.scoped_to(authentication.current_user) do | user |
+                Lanes.logger.debug "User   : #{user.id} (#{user.login})"
+                Lanes.logger.debug "Params : #{request.params}"
+
+                params[:nested_attribute] = Hash[ parent_attribute, params[parent_attribute] ] if parent_attribute
+
+                wrap_json_reply do
+                    yield authentication
+                end
+
+            end
+        end
+
+        def wrap_json_reply
+            response = yield
+            if false == response[:success]
+                status(406)
+            end
+            Oj.dump(response, mode: :compat)
+        end
+
+    end
+
+
+end

data/lib/lanes/api/root.rb

@@ -0,0 +1,103 @@
+require 'sinatra'
+require 'oj'
+require 'rack/csrf'
+require 'sprockets-helpers'
+require 'message_bus'
+require_relative 'asset_pipeline'
+require_relative 'helper_methods'
+require_relative 'pub_sub'
+
+module Lanes
+    module API
+        class Root < Sinatra::Application
+            set :environment, Lanes.config.environment
+            Lanes.config.get(:environment) do | env |
+                set :environment, env
+            end
+            register AssetPipeline
+            helpers Sinatra::RequestWrapper
+            helpers HelperMethods
+            not_found do
+                Oj.dump({ message: "endpoint not found", success: false  })
+            end
+            before do
+                content_type 'application/json'
+            end
+
+            use Rack::Session::Cookie, :key => 'lanes.session', :secret => Lanes.config.session_secret_key_base
+            use ActiveRecord::ConnectionAdapters::ConnectionManagement
+            use MessageBus::Rack::Middleware
+            error do
+                Lanes.logger.warn request.env['sinatra.error']#.backtrace
+                Oj.dump({
+                    success: false,
+                    errors:  { exception: request.env['sinatra.error'].message },
+                    message: request.env['sinatra.error'].message
+                })
+            end
+
+            configure do
+                set :views, Pathname.new(__FILE__).dirname.join("../../../views")
+                set :show_exceptions, false
+                DB.establish_connection
+                PubSub.initialize
+                # use Rack::Csrf, :skip=>['GET:/'], :raise => true
+            end
+
+            def self.build_route(model, options = {})
+
+                path = options[:path] || model.api_path
+                controller = options[:controller] || Lanes::API::Controller
+
+                parent_attribute = false
+                prefix = if options[:under]
+                             parent_attribute = options[:parent_attribute] || options[:under].underscore.singularize+'_id'
+                         else
+                             ''
+                         end
+
+
+                # index
+                get "#{prefix}/#{path}/?:id?.json" do
+                    wrap_request(model, params, parent_attribute) do |authentication|
+                        controller.new(model, authentication, params).perform_retrieval
+                    end
+                end
+
+                # create
+                post "#{prefix}/#{path}.json" do
+                    wrap_request(model, params, parent_attribute) do |authentication|
+                        controller.new(model, authentication, params, data).perform_creation
+                    end
+                end
+
+                unless options[:immutable]
+                    patch "#{prefix}/#{path}/:id.json" do
+                        perform_request(model, params, parent_attribute) do |authentication|
+                            controller.new(model, authentication, params, data).perform_update
+                        end
+                    end
+
+                    # update
+                    put "#{prefix}/#{path}/:id.json" do
+                        wrap_request(model, params, parent_attribute) do |authentication|
+                            controller.new(model, authentication, params, data).perform_update
+                        end
+                    end
+
+                    unless options[:indestructible]
+                        # destroy
+                        delete "#{prefix}/#{path}/:id.json" do
+                            wrap_request(model, params, parent_attribute) do |authentication|
+                                controller.new(model, authentication, params).perform_destroy
+                            end
+                        end
+                    end
+
+                end
+
+            end
+
+        end
+    end
+end

data/lib/lanes/api/skr_templates.rb

@@ -0,0 +1,60 @@
+# 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/api/test_specs.rb

@@ -0,0 +1,59 @@
+require 'jasmine-core'
+
+module Lanes
+    module API
+
+        class TestSpecs
+            cattr_accessor :current
+
+            def initialize(root)
+                @root = root
+            end
+
+            def css_files
+                urlpath Jasmine::Core.css_files
+            end
+
+            def js_files
+                urlpath(Jasmine::Core.js_files)   +
+                urlpath(Jasmine::Core.boot_files) +
+                urlpath(spec_files("helpers"))    +
+                urlpath(spec_files("client"))
+            end
+
+          private
+
+            def spec_files(path)
+                dir = @root.join("spec")
+                regex = /^#{dir}\//
+                Dir.glob( dir.join(path,"**/*.{coffee,js}") ).map do |file|
+                    file.sub(regex,'').sub(/coffee$/,'js')
+                end
+            end
+
+            def urlpath(files)
+                files.map{ |file| "/spec/"+file }
+            end
+        end
+
+        Lanes.config.get(:specs_root) do | root |
+            TestSpecs.current = TestSpecs.new(root)
+            Root.sprockets.append_path(root.join("spec"))
+        end
+
+        Root.sprockets.append_path(Jasmine::Core.path)
+
+        Root.get '/spec' do
+            content_type 'text/html'
+            erb :specs, locals: { specs: TestSpecs.current }
+        end
+
+        Root.get "/spec/*" do |path|
+            env_sprockets = request.env.dup
+            env_sprockets['PATH_INFO'] = path
+            settings.sprockets.call env_sprockets
+        end
+
+
+    end
+end

data/lib/lanes/api/updates.rb

@@ -0,0 +1,38 @@
+module Lanes
+
+    module API
+
+        module Updates
+            @relaying_messages = false
+
+            def self.user_info_for_change(model)
+                if model.has_attribute?(:updated_by_id)
+                    model.updated_by.as_json(only:[:id,:name,:email])
+                else
+                    {}
+                end
+            end
+
+            def self.relay!
+                if @relaying_messages
+                    raise "Already relaying messages, calling relay! twice will lead to message duplication"
+                end
+                @relaying_messages = true
+                Lanes::Model.observe(:save) do |model|
+                    if model.changes.any?
+                        path = "/#{model.class.api_path}/#{model.id}"
+
+                        Lanes::API::PubSub.publish(path, {
+                            by: self.user_info_for_change(model),
+                            update: model.changes
+                          })
+                    end
+                end
+
+            end
+
+        end
+
+
+    end
+end

data/lib/lanes/api.rb

@@ -0,0 +1,27 @@
+require_relative 'api/authentication_helper'
+require_relative 'api/authentication_provider'
+
+require_relative 'api/request_wrapper'
+require_relative 'api/error_formatter'
+require_relative 'api/controller'
+require_relative 'api/root'
+require_relative 'api/default_routes'
+# require_relative 'api/login_sessions_controller'
+# require_relative 'api/users_controller'
+
+require_relative "api/pub_sub"
+
+
+Lanes.config.get(:environment) do
+    require_relative("api/test_specs") if Lanes.env.test?
+end
+
+# Lanes::API::Root.routes['GET'].each do |route|
+#   puts route[0]
+# end
+
+# require_relative "api/skr_templates"
+# if defined?(::Rails)
+#     require_relative "api/engine"
+#     require_relative "api/route_helper"
+# end

data/lib/lanes/cli.rb

@@ -0,0 +1,13 @@
+require 'thor'
+require_relative '../lanes'
+require_relative 'generators/app'
+
+module Lanes
+
+    class CLI < Thor
+
+        register Generators::App, 'new', 'new [NAME]', 'Creates a new Lanes based application'
+
+    end
+
+end

data/lib/lanes/concerns/all.rb

@@ -0,0 +1,16 @@
+require_relative "api_path"
+require_relative "association_extensions"
+require_relative "attr_accessor_with_default"
+require_relative "code_identifier"
+require_relative "export_associations"
+require_relative "export_join_tables"
+require_relative "export_methods"
+require_relative "export_scope"
+require_relative "immutable_model"
+require_relative "set_attribute_data"
+require_relative "locked_fields"
+require_relative "pub_sub"
+require_relative "queries"
+require_relative "random_hash_code"
+require_relative "sanitize_api_data"
+require_relative "visible_id_identifier"

data/lib/lanes/concerns/api_path.rb

@@ -0,0 +1,21 @@
+module Lanes::Concerns
+
+    # @see ClassMethods
+    module ApiPath
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            def api_path
+                self.to_s.demodulize.pluralize.underscore.dasherize
+            end
+
+            def from_api_path(path)
+                name = path.underscore.camelize.singularize
+                name = "Lanes::#{name}" unless name=~/^Lanes/
+                name.safe_constantize
+            end
+
+        end
+    end
+end

data/lib/lanes/concerns/association_extensions.rb

@@ -0,0 +1,85 @@
+module Lanes::Concerns
+
+
+    # Custom implentation of has_many and belongs_to
+    #
+    module AssociationExtensions
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            def has_one(name, scope = nil, options = {})
+                opts = extract_private_options( scope, options )
+                associations = super
+                handle_private_options( name, opts ) unless opts.empty?
+                associations
+            end
+
+            def belongs_to(name, scope = nil, options = {} )
+                opts = extract_private_options( scope, options )
+                associations = super
+                handle_private_options( name, opts ) unless opts.empty?
+                associations
+            end
+
+            def has_many(name, scope=nil,options={}, &extension )
+                opts = extract_private_options( scope, options )
+                associations = super
+                handle_private_options( name, opts ) unless opts.empty?
+                associations
+            end
+
+            private
+
+            def handle_private_options( name, opts )
+                association = reflect_on_association( name.to_sym )
+                setup_listeners( association, opts[:listen] ) if opts[:listen]
+                setup_association_export( association, opts[:export] ) if opts[:export]
+            end
+
+            def extract_private_options( scope, options )
+                if scope.is_a?(Hash)
+                    scope.extract!( :export, :listen )
+                else
+                    options.extract!( :export, :listen )
+                end
+            end
+
+            # This gets complex; We
+            #   First setup proc's for each listener,
+            #   then attempt to load the associations's class
+            #   If that succeds, we're done, otherwise we add it
+            #   to PubSub's pending queue
+            def setup_listeners( association, listeners )
+                targets = {}
+                if listeners.any? && association.options[:inverse_of].nil?
+                    raise ArgumentError.new "Setting listener on #{name}##{association.name} " +
+                        "but the association does not have " +
+                        "an inverse_of specified."
+                end
+                listeners.each do | name, target |
+                    targets[ name ] = Proc.new{ | record, *args |
+                        record = record.send( association.inverse_of.name )
+                        record.send( target, *( [record] + args ) ) if record
+                    }
+                end
+                begin
+                    klass = association.klass # This will throw if the class hasn't been loaded yet
+                    targets.each{ | name, proc | klass._add_event_listener( name, proc ) }
+                rescue NameError
+                    pending = PendingEventListeners.all[association.class_name.demodulize]
+                    targets.each do | name, proc |
+                        pending[name] << proc
+                    end
+                end
+            end
+
+            def setup_association_export( association, options )
+                export_associations( association.name, options == true ? {} : options )
+            end
+        end
+
+    end
+
+end

data/lib/lanes/concerns/attr_accessor_with_default.rb

@@ -0,0 +1,62 @@
+module Lanes::Concerns
+
+    # @see ClassMethods
+    module AttrAccessorWithDefault
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+            # defines a attr_accessor with a default value
+            # @param name [ Symbol ] name of the attribute
+            # @param default [ Object, lambda, Proc ] if a value is given, be aware that it will be shared between instances
+            # @example
+            #
+            #     Shared = Struct.new(:str)
+            #     class AttrTestClass
+            #         include AttrAccessorWithDefault
+            #         attr_accessor_with_default :non_copying, ->{ Shared.new("a default string") }
+            #         attr_accessor_with_default :shared, Shared.new("a default string")
+            #     end
+            #     a = AttrTestClass.new
+            #     b = AttrTestClass.new
+            #     a.non_copying.str                   #=> "a default string"
+            #     a.non_copying.str  = "new_string"   #=> "new string"
+            #     b.non_copying.str                   #=> "a default string"
+            #
+            #     a.shared.str                   #=> "a default string"
+            #     b.shared.str                   #=> "a default string"
+            #     a.shared.str = "new string"    #=> "new string"
+            #     b.shared.str                   #=> "new string"
+
+            def attr_accessor_with_default( name, default=nil )
+                attr_writer name
+                attr_add_default_setting_method(name)
+                attr_reader_with_default( name, default )
+            end
+
+            def attr_add_default_setting_method(name)
+                module_eval do
+                    define_singleton_method(name) do | value |
+                        attr_reader_with_default( name, value )
+                    end
+                end
+            end
+            def attr_reader_with_default( name, default )
+                module_eval do
+                    define_method( name ) do
+                        class << self; self; end.class_eval do
+                            attr_reader( name )
+                        end
+                        if instance_variables.include? "@#{name}"
+                            instance_variable_get( "@#{name}" )
+                        else
+                            instance_variable_set( "@#{name}", default.is_a?(Proc) ? default.call : default )
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+
+end

data/lib/lanes/concerns/code_identifier.rb

@@ -0,0 +1,43 @@
+module Lanes
+    module Concerns
+
+        # @see ClassMethods
+        module CodeIdentifier
+
+            extend ActiveSupport::Concern
+
+            # ### Code Identifier Concern
+            # This adds the {#has_code_identifier} class method
+            module ClassMethods
+
+                # A 2-10 character string that identifies an entity, such as a Customer, Vendor, or SKU.
+                # The code is often assigned by the user, but may also
+                # be auto-generated by {Lanes::Strings.code_identifier}
+                #
+                # @param max_length [Integer] how long the code is allowed to be
+                # @param from [Symbol], method to call for a string to base the code upon
+                def has_code_identifier( from: nil, max_length: 10 )
+
+                    validates :code, :length=>2..max_length, :presence=>true, :uniqueness=>true
+
+                    alias_attribute :record_identifier, :code
+
+                    if from
+                        before_validation(:on=>:create) do
+                            source = self[from]
+                            unless source.blank?
+                                self.code ||= Lanes::Strings.code_identifier( source, length:max_length )
+                            end
+                        end
+                    end
+
+                    before_validation do
+                        self.code = self.code.upcase unless self.code.blank?
+                    end
+                end
+
+            end
+
+        end
+    end
+end

data/lib/lanes/concerns/export_associations.rb

@@ -0,0 +1,52 @@
+module Lanes::Concerns
+
+    # @see ClassMethods
+    module ExportAssociations
+        extend ActiveSupport::Concern
+
+        included do
+            class_attribute :exported_associations
+        end
+
+        module ClassMethods
+            # Mark associations as exported, meaning they can be quered against and optionally written to
+            # @param associations [list of Symbols]
+            # @option options [Boolean] :writable should the associations accept nested attributes
+            # @option options [Boolean] :mandatory should the association be included with it's parent at all times?
+            # @option options [Symbol referring to a method, lambda] :limit restrict to Users for whom true is returned
+            def export_associations( *associations )
+                self.exported_associations ||= {}
+                associations.flatten!
+                options = associations.extract_options!
+                associations.each do | assoc_name |
+                    self.exported_associations[ assoc_name.to_sym ] = options
+                    if options[:writable]
+                        accepts_nested_attributes_for( assoc_name, options.except(:writable, :optional) )
+                    end
+                    if false == options[:optional]
+                        self.export_methods( *assoc_name, { :optional=>false })
+                    end
+                end
+            end
+
+            # If the association is exported it may be queried against and it's data included
+            # along with the parent record.  It may not be written to unless the :writable flag
+            # was set, in which case it'll be allowed by has_exported_association?
+            def has_exported_association?( association, user )
+                self.exported_associations &&
+                    ( options = self.exported_associations[ association.to_sym ] ) &&
+                    evaluate_export_limit( user, :association, association, options[:limit] )
+            end
+
+            # Does the association allow writes?  True if the association has been exported
+            # and it accepts nested attributes
+            def has_exported_nested_attribute?( association, user )
+                self.nested_attributes_options[ association.to_sym ] &&
+                    self.has_exported_association?( association, user )
+            end
+
+        end
+
+    end
+
+end