lanes 0.0.3 → 0.0.5

data/lib/lanes/command/templates/lib/namespace/model.rb

@@ -0,0 +1,7 @@
+module <%= namespace.camelize %>
+
+    class <%= class_name %> < <%= options[:parent] %>
+
+    end
+
+end

data/lib/lanes/command/templates/lib/namespace/screen.rb

@@ -0,0 +1,17 @@
+require 'lanes'
+
+module <%= namespace.camelize %>
+
+    class <%= class_name %>Screen < Lanes::Screens::Definition
+
+        identifier  "<%= name.dasherize %>"
+        title       "<%= options[:title] %>"
+        description "<%= options[:description] %>"
+        icon        "<%= options[:icon] %>"
+        group_id    "<%= options[:group] %>"
+        model_class "<%= options[:model_class] %>"
+        view_class  "<%= namespace.camelize %>.Screens.<%= class_name %>"
+        files       ['screens/<%= name.dasherize %>.js','screens/<%= name.dasherize %>.css']
+    end
+
+end

data/lib/lanes/command/templates/lib/namespace/version.rb

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

data/lib/lanes/command/templates/lib/namespace.rb

@@ -0,0 +1,12 @@
+require "lanes"
+require 'require_all'
+require_relative "<%= name %>/version.rb"
+require_relative "<%= name %>/extension.rb"
+require_rel '<%= name %>'
+
+# The main namespace for <%= name.camelize %>
+module <%= namespace.camelize %>
+    def self.table_name_prefix
+        "<%= name %>_"
+    end
+end

data/lib/lanes/command/templates/spec/client/data/ModelSpec.coffee

@@ -0,0 +1,5 @@
+describe "<%= class_name %> Model Suite", ->
+
+    it "can be instantiated", ->
+        model = new Lanes.<%= namespace.camelize %>.Data.<%= class_name %>()
+        expect(model).toEqual(jasmine.any(Lanes.<%= namespace.camelize %>.Data.<%= class_name %>));

data/lib/lanes/command/templates/spec/client/views/ViewSpec.coffee

@@ -0,0 +1,5 @@
+describe "<%= class_name %> View Suite", ->
+
+    it "can be instantiated", ->
+        view = new Lanes.<%= namespace.camelize %>.Views.<%= class_name %>()
+        expect(view).toEqual(jasmine.any(Lanes.<%= namespace.camelize %>.Views.<%= class_name %>));

data/lib/lanes/command/templates/spec/fixtures/namespace/model.yml

@@ -0,0 +1,16 @@
+# Read about fixtures at http://api.rubyonrails.org/classes/ActiveRecord/FixtureSet.html
+<% unless fields.empty? -%>
+<% %w(first second).each do |name| %>
+<%= name %>:
+<% fields.each do |attribute| -%>
+  <%- if attribute.password_digest? -%>
+  password_digest: <%%= BCrypt::Password.create('secret') %>
+  <%- else -%>
+  <%= yaml_key_value(attribute.column_name, attribute.default) %>
+  <%- end -%>
+  <%- if attribute.polymorphic? -%>
+  <%= yaml_key_value("#{attribute.name}_type", attribute.human_name) %>
+  <%- end -%>
+<% end -%>
+<% end %>
+<% end %>

data/lib/lanes/command/templates/spec/namespace/model_spec.rb

@@ -0,0 +1,10 @@
+require_relative 'spec_helper'
+
+describe <%= namespace.camelize %>::<%= class_name %> do
+
+    it "can be instantiated" do
+        model = <%= class_name %>.new
+        model.must_be_instance_of(<%= class_name %>)
+    end
+
+end

data/lib/lanes/command/templates/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'lanes/spec_helper'
+
+module <%= namespace %>
+
+    # Add more helper methods to be used by all tests here...
+
+    class TestCase < Lanes::TestCase
+
+    end
+
+    class ApiTestCase < Lanes::ApiTestCase
+
+    end
+
+end

data/lib/lanes/command/update.rb

@@ -0,0 +1,13 @@
+module Lanes
+    module Command
+
+        class Update < Thor
+
+            desc 'update model [NAME]', 'Updates a model'
+            long_desc Command.usage_from_file("update_model")
+            register Command::UpdateModel, 'model', 'model [NAME]', 'Updates a client model to match the server definition'
+
+        end
+
+    end
+end

data/lib/lanes/command/update_model.rb

@@ -0,0 +1,125 @@
+require_relative 'model_attribute'
+
+module Lanes
+    module Command
+
+        class UpdateModel < Thor::Group
+
+            include Thor::Actions
+
+            argument :name
+            attr_reader :namespace, :class_name, :namespaced_name
+
+            def self.source_root
+                Pathname.new(__FILE__).dirname.join("templates")
+            end
+
+            def read_class
+                if name=~/::/
+                    (@namespace,@name) = name.split("::")
+                else
+                    ext = Command.load_current_extension
+                    @namespace = ext.identifier
+                end
+                class_name = name.camelize
+                namespaced_name = "#{namespace.classify}::#{class_name}"
+                @klass = namespaced_name.safe_constantize
+                if !@klass
+                    raise Thor::Error.new("#{namespaced_name} was not found")
+                end
+                @file = Pathname.new("client/data/#{class_name}.coffee")
+                unless @file.exist?
+                    raise Thor::Error.new("Model #{@file} doesn't exist")
+                end
+                Lanes::DB.establish_connection
+            end
+
+            def replace_props
+                columns = columns_for(@klass)
+                return unless columns.any? # could happen I guess?
+                (props,indent) = read_indent('props')
+                maxlen = columns.map{|field| field.name.length }.max
+                contents = props
+                columns.each do | column |
+                    contents << sprintf("#{indent}%-#{maxlen+1}s",column.name+':') + type_specification(column) + "\n"
+                end
+                gsub_file @file, /props\s*:\s*\n.*?\n(?!#{indent})/m, contents
+            end
+
+            def replace_associations
+                associations = associations_for(@klass)
+                return unless associations.any?
+                (section,indent) = read_indent('associations',optional: true)
+                maxlen = associations.map{|field| field.name.length }.max
+                contents = section || (
+                               single_indent = @file.read[/\n(\h+)(\w+):/,1] || '    '
+                               indent = single_indent*2
+                               "\n#{single_indent}associations:\n"
+                             )
+                associations.each do | assoc |
+                    type = assoc.collection? ? 'collection' : 'model'
+                    contents << sprintf("#{indent}%-#{maxlen+2}s",assoc.name.to_s+':') + \
+                                "{ #{type}: \"#{assoc.class_name.demodulize}\" }\n"
+                end
+                if section
+                    gsub_file @file, /associations\s*:\s*\n.*?\n(?!#{indent})/m, contents
+                else
+                    gsub_file @file, /\n\z/m, contents
+                end
+            end
+
+          private
+
+            def read_indent(section, optional: false)
+                  contents = @file.read
+                  match = contents.match(/(#{section}\s*:\s*\n+)(\s+)\w/m)
+                  return match.captures if match
+                  if optional
+                      return [nil,nil]
+                  else
+                      raise Thor::Error.new("Unable to detect #{section} section")
+                  end
+            end
+
+            def type_specification(column)
+                if column.null
+                    '"' + type_for_column(column) + '"'
+                else
+                    type = { type: type_for_column(column), required: true }
+                    if column.default
+                        type[:default] = column.default
+                    end
+                    type.to_json
+                end
+            end
+
+            def associations_for(klass)
+                klass.reflect_on_all_associations.reject{|assoc| assoc.name =~ /^(created|updated)_by/ }
+            end
+
+            def columns_for(klass)
+                klass.columns.reject{ |column| column.name =~ /^(created|updated)_/ }
+            end
+
+            def type_for_column(column)
+                if column.array
+                    'array'
+                elsif column.sql_type == 'json'
+                    'object'
+                else
+                    case column.type
+                    when :datetime then 'date'
+                    when :integer  then 'integer'
+                    when :float    then 'number'
+                    when :text     then 'string'
+                    when :string   then 'string'
+                    when :boolean  then 'boolean'
+                    when :decimal  then 'bigdec'
+                    else 'any'
+                    end
+                end
+            end
+
+        end
+    end
+end

data/lib/lanes/command/update_model.usage

@@ -0,0 +1,2 @@
+Updates a model's client definition to match the fields
+that are defined on the server.

data/lib/lanes/command.rb

@@ -0,0 +1,37 @@
+module Lanes
+    module Command
+        class << self
+
+            # Reads and returns the contents of a usage file.  Used
+            # internally by commands to populate their long_desc
+            # @param [String] basename of file to read usage from
+            def usage_from_file(file)
+                Pathname.new(__FILE__).dirname.join("command","#{file}.usage").read
+            end
+
+            # Loads the code for the extension that the user is currently
+            # working inside.  The `lanes` command uses this to detect
+            # what actions should be taken.
+            #
+            # Will silently swallow any exceptions that are raised when the file is required and return nil
+            #
+            # @return [Extension] extension that was loaded, nil if none was found
+            def load_current_extension
+                previous = Extensions.all
+                ext = Dir.glob("./lib/**/extension.rb").first
+                if ext
+                    begin
+                        require(ext)
+                    rescue
+                        return nil
+                    end
+                    diff = Extensions.all - previous
+                    return diff.any? ? diff.first.new : nil
+                else
+                    return nil
+                end
+            end
+
+        end
+    end
+end

data/lib/lanes/components.rb

@@ -0,0 +1,45 @@
+require 'pry'
+module Lanes
+
+    module Components
+        @@enabled = []
+
+        class << self
+
+            # @param names [Symbol] list of components to include in applications
+            def enable(*names)
+                @@enabled += names.map(&:to_sym)
+                @@enabled.uniq!
+            end
+
+            def enabled(&block)
+                @@enabled.each{ |component| yield component }
+            end
+
+            # Called by sprockets during processing from the client/components/enabled.js.erb
+            # Requires the enabled components and all of their dependencies
+            def enabled_with_dependencies(env, &block)
+                enabled do | component |
+                    depends = component_configuration(component, env.environment)['depends']
+                    depends.each{ |d| yield d } if depends
+                    yield component
+                end
+            end
+
+            # @param component [String,Symbol] component name to lookup
+            # @return Hash configuration for component, read from a config.json file in the components directory,
+            # or an empty hash if no configuration is present
+            def component_configuration(component, env)
+                if asset = env.find_asset("components/#{component}")
+                    config_file = asset.pathname.dirname.join("config.json")
+                    if config_file.exist?
+                        return Oj.load(config_file.read)
+                    end
+                end
+                return {}
+            end
+
+        end
+    end
+
+end

data/lib/lanes/concerns/set_attribute_data.rb

@@ -55,7 +55,7 @@ module Lanes::Concerns
                 attributes.each{|attr| self.blacklisted_attributes[ attr.to_sym ] = options }
             end
 
-            def from_attribute_data(data,user=Lanes::User.current)
+            def from_attribute_data(data,user)
                 record = self.new
                 record.set_attribute_data(data, user)
                 record
@@ -84,7 +84,7 @@ module Lanes::Concerns
         # @param data [Hash]
         # @param user [User] who is performing request
         # @returns
-        def set_attribute_data(data, user = Lanes::User.current)
+        def set_attribute_data(data, user)
 
             return {} unless self.can_write_attributes?(data, user)
 

data/lib/lanes/configuration.rb

@@ -1,6 +1,6 @@
 require_relative "concerns/attr_accessor_with_default"
 require 'securerandom'
-
+require 'pathname'
 module Lanes
 
     class Configuration
@@ -65,9 +65,9 @@ module Lanes
         config_option :es6_transpiler_path, '6to5'
         config_option :es6_transpiler_options, '-t '
         config_option :app_title, "Lanes Test"
-
+        config_option :assets_path_prefix, "/assets"
         config_option :mounted_at, ''
-
+        config_option :root_view, 'Lanes.Workspace.Layout'
         config_option :specs_root, Pathname.getwd
     end
 

data/lib/lanes/db.rb

@@ -1,5 +1,3 @@
-require_relative 'db/seed'
-
 module Lanes
 
     module DB
@@ -18,21 +16,17 @@ module Lanes
             ::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!
+            path = Pathname.new("./db/seed.rb")
+            load path if path.exist?
         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'
+            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
@@ -41,34 +35,6 @@ module Lanes
             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
 

data/lib/lanes/extension.rb

@@ -1,24 +1,49 @@
 module Lanes
 
-    class Extension
+    module Extensions
 
-        def initialize(*args)
-        end
+        class Definition
+            include Concerns::AttrAccessorWithDefault
+
+            attr_reader :context
+
+            attr_accessor_with_default :load_phase, :late
+
+            attr_accessor_with_default :identifier
+
+            # Array of Pathname's to add to sprockets
+            attr_accessor_with_default :root_path
+
+            # Load extension before/after the named extensions
+            class_attribute :before
+            class_attribute :after
 
-        class_attribute :identifier
+            def self.components(*names)
+                Components.enable(*names)
+            end
 
-        # [String] The path for including the extension in the asset pipeline
-        class_attribute :logical_path
+            def client_bootstrap_data(view)
+                {}
+            end
 
+            def javascript_include
+                self.identifier + ".js"
+            end
 
-        # [String] The directory that holds the the root of the asset pipeline
-        class_attribute :asset_path
+            def client_namespace
+                identifier.underscore.camelize
+            end
 
-        class_attribute :before
-        class_attribute :after
+            def client_paths
+                [ self.root_path.join("client") ]
+            end
 
-        def bootstrap_data(view)
-            {}
+            def route(route_set)
+                routes_config = root_path.join('config','routes.rb')
+                if routes_config.exist?
+                    require routes_config
+                end
+            end
         end
 
         class << self
@@ -31,8 +56,12 @@ module Lanes
                 self.before = extension
             end
 
-            def active
-                unmapped = self.descendants
+            def all
+                Definition.descendants
+            end
+
+            def sorted
+                unmapped = all
                 mapped   = []
                 while unmapped.any?
                     mapped_count = mapped.length
@@ -55,17 +84,33 @@ module Lanes
                 mapped
             end
 
-            def each(config={})
-                self.active.each{ |klass| yield klass.new(config) }
+            def each
+                sorted.map{ |klass| yield klass.new }
             end
 
-            def bootstrap_data(env)
-                data = { 'roles' => Lanes::Access::Role.all_available }
+            def early_loaded
+                each{ |ext| yield ext if ext.load_phase == :early }
+            end
+
+            def late_loaded
+                each{ |ext| yield ext if ext.load_phase == :late  }
+            end
+
+            def client_bootstrap_data(view)
+                data = {}
                 each do | ext |
-                    data[ext.identifier] = data.bootstrap_data(env)
+                    data[ext.identifier] = ext.client_bootstrap_data(view)
                 end
                 return data
             end
+
+            def load_current_config
+                config_file = Pathname.getwd.join('config','lanes.rb')
+                if config_file.exist?
+                    require config_file
+                end
+            end
+
         end
 
     end

data/lib/lanes/guard_tasks.rb

@@ -1,5 +1,6 @@
 require_relative "../lanes"
-require 'guard'
+require 'guard/jasmine'
+require 'guard/minitest'
 
 module Lanes
     module GuardTasks
@@ -20,12 +21,13 @@ module Lanes
             matchers = CustomMatchers.new
             yield matchers
 
-            jasmine_options = {
-                server_mount: '/spec', server_env: 'test', server: :puma, spec_dir: 'spec/client', debug: false
-            }
+            jasmine_options = options.merge({
+                port: 8888, server_mount: '/spec', server_env: 'test', server: :puma,
+                spec_dir: 'spec/client', console: :always, 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{^client/(.+?)\.(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

data/lib/lanes/rake_tasks.rb

@@ -0,0 +1,47 @@
+require 'puma/control_cli'
+require_relative '../lanes'
+
+desc "Run the puma server in development mode"
+task :dev do
+    Puma::ControlCLI.new(['start']).run
+end
+
+desc "Open an irb session configured with the Lanes environment"
+task :console do
+    require 'irb'
+    require 'irb/completion'
+    require 'pp'
+    include Lanes
+    DB.establish_connection
+    ActiveRecord::Base.logger = Logger.new STDOUT
+    ARGV.clear
+    IRB.start
+end
+
+
+# ## quite a bit of this is cribbed from Sinatra ActiveRecord
+load 'active_record/railties/databases.rake'
+
+task :routes do
+    require 'lanes/api'
+    Lanes::API::Root.routes.each do |verb,handlers|
+        puts "\n#{verb}:\n"
+        handlers.each do |handler|
+            puts handler[0].source.to_s.gsub("\\A",'').gsub("\\z",'')
+        end
+    end
+end
+
+
+namespace :db do
+    task :environment do
+        Lanes::DB.configure_rake_environment
+    end
+end
+
+namespace :assets do
+    task :precompile do
+        require_relative 'api/sprockets_extension'
+        Lanes::API::SprocketsExtension.compile!
+    end
+end