lanes 0.1.9 → 0.1.9.5

data/lib/lanes/api/test_specs.rb

@@ -20,7 +20,7 @@ module Lanes
             def js_files
                 urlpath(Jasmine::Core.js_files)   +
                 urlpath(Jasmine::Core.boot_files) +
-                [ '/assets/lanes/testing' ] +
+                ['/assets/lanes/testing'] +
                 urlpath(spec_files(extension.identifier))
             end
 
@@ -29,8 +29,8 @@ module Lanes
             def spec_files(path)
                 dir = extension.root_path.join("spec")
                 regex = /^#{dir}\//
-                Dir.glob( dir.join(path,"**/*.{coffee,js}") ).map do |file|
-                    file.sub(regex,'').sub(/coffee$/,'js')
+                Dir.glob( dir.join(path,"**/*.{coffee,cjsx,js}") ).map do |file|
+                    file.sub(regex,'').sub(/(coffee|cjsx)$/,'js')
                 end
             end
 

data/lib/lanes/cli.rb

@@ -17,9 +17,14 @@ module Lanes
         desc "generate SUBCOMMAND ...ARGS", "Generate a component"
         subcommand "generate", Command::Generate
 
-        desc "update SUBCOMMAND ...ARGS", "Update a component"
+        desc "update SUBCOMMAND ...ARGS", "Update a model"
         subcommand "update", Command::Update
 
+        desc "version", "Display version of lanes"
+        def version
+            puts Lanes::VERSION
+        end
+
         long_desc Command.usage_from_file("server")
         register Command::Server,  'serve', 'serve', 'Run the app in development/testing mode'
 

data/lib/lanes/command/app.rb

@@ -25,6 +25,9 @@ module Lanes
                 template "lib/namespace/version.rb", "lib/#{identifier}/version.rb"
                 template "lib/namespace/extension.rb", "lib/#{identifier}/extension.rb"
                 template "lib/namespace/base_model.rb", "lib/#{identifier}/model.rb"
+                template "../coffeelint.json", "coffeelint.json"
+                template "../.rubocop.yml", ".rubocop.yml"
+                template "config/screens.rb"
                 template "config/routes.rb"
                 template "config/lanes.rb"
                 template "gitignore",".gitignore"
@@ -32,7 +35,7 @@ module Lanes
                 create_file "log/.gitkeep",""
                 create_file "tmp/.gitkeep",""
                 create_file "db/.gitkeep", ""
-                create_file "config/screens.rb"
+
             end
 
             def create_client_files
@@ -42,10 +45,9 @@ module Lanes
                     create_file "#{client_dir}/#{path.basename}/.gitkeep"
                 end
                 template "client/models/BaseModel.coffee", "#{client_dir}/models/Base.coffee"
-                template "client/views/BaseView.coffee",   "#{client_dir}/views/Base.coffee"
+                template "client/components/BaseComponent.coffee",   "#{client_dir}/components/Base.coffee"
                 template "client/index.js",                "#{client_dir}/index.js"
                 template "client/Extension.coffee",        "#{client_dir}/Extension.coffee"
-                template "client/Router.coffee",           "#{client_dir}/Router.coffee"
                 template "client/styles.scss",             "#{client_dir}/styles.scss"
             end
 
@@ -56,15 +58,9 @@ module Lanes
                          "spec/server/spec_helpers.rb"
             end
 
-            def create_first_screen
+            def create_screen_base
                 options = self.options.dup
-                @class_name = "Base"
-                @template = "<div><h1>Base Screen</h1></div>"
-                options[:description] = "Base Screen for #{namespace.titleize}"
-                options[:fileless] = true
-                template "client/screens/Base.coffee", "#{client_dir}/screens/Base.coffee"
-                template "spec/client/Screen.coffee",    "#{spec_dir}/screens/Base.coffee"
-                create_file "config/screens.rb", ""
+                template "client/screens/BaseScreen.coffee", "#{client_dir}/screens/Base.coffee"
             end
 
         end

data/lib/lanes/command/generate.rb

@@ -11,9 +11,9 @@ module Lanes
             method_options( GenerateScreen::OPTIONS )
             register Command::GenerateScreen, 'screen', 'screen [NAME]', 'Creates a new Screen'
 
-            long_desc Command.usage_from_file("generate_view")
-            method_options( GenerateView::OPTIONS )
-            register Command::GenerateView, 'view', 'view [NAME]', 'Creates a new View'
+            long_desc Command.usage_from_file("generate_component")
+            method_options( GenerateComponent::OPTIONS )
+            register Command::GenerateComponent, 'component', 'component [NAME]', 'Creates a new Component to be shared between screens'
 
         end
 

data/lib/lanes/command/generate_component.rb

@@ -0,0 +1,28 @@
+require_relative 'model_attribute'
+
+module Lanes
+    module Command
+
+        class GenerateComponent < NamedCommand
+            OPTIONS ||= {
+              namespace: nil,
+            }
+            class_options( OPTIONS )
+            attr_reader :component_class
+
+            def set_variables
+                super
+                @component_class = "#{namespace}.Components.#{class_name}"
+            end
+
+            def create_component
+                template "client/components/Component.cjsx",   "#{client_dir}/components/#{class_name}.cjsx"
+                template "spec/client/components/ComponentSpec.coffee", \
+                         "#{spec_dir}/components/#{class_name}Spec.coffee"
+            end
+
+
+        end
+
+    end
+end

data/lib/lanes/command/generate_component.usage

@@ -0,0 +1,11 @@
+Stubs out a new Component. 
+
+When executed inside a project called "Blog":
+
+`lanes generate component comment`
+
+Lanes will create:
+····················
+
+  * Component: client/components/Comment.coffee
+  * Spec: spec/<app>/components/CommentSpec.coffee

data/lib/lanes/command/generate_screen.rb

@@ -14,28 +14,45 @@ module Lanes
             }
             class_options( OPTIONS )
 
-            attr_reader :screen_id
+            attr_reader :screen_id, :screen_class
 
             def set_variables
                 super
                 options[:title] = name.titleize if options[:title].blank?
                 @screen_id = class_name.underscore.dasherize
+                @screen_class = "#{namespace}.Screens.#{class_name}"
             end
 
             def create_screen
-                template "client/screens/index.js",      "#{client_dir}/screens/#{screen_id}/index.js"
-                template "client/screens/styles.scss",   "#{client_dir}/screens/#{screen_id}/index.scss"
-                template "client/screens/Screen.coffee", "#{client_dir}/screens/#{screen_id}/#{class_name}.coffee"
-                template "client/screens/layout.html",   "#{client_dir}/screens/#{screen_id}/layout.html"
-                template "spec/client/Screen.coffee",    "#{spec_dir}/screens/#{screen_id}/#{class_name}Spec.coffee"
+                template "client/screens/index.js",    "#{client_dir}/screens/#{screen_id}/index.js"
+                template "client/screens/styles.scss", "#{client_dir}/screens/#{screen_id}/index.scss"
+                template "client/screens/Screen.cjsx", "#{client_dir}/screens/#{screen_id}/#{class_name}.cjsx"
+                template "spec/client/Screen.coffee",  "#{spec_dir}/screens/#{screen_id}/#{class_name}Spec.coffee"
             end
 
             def add_definition
-                append_to_file "config/screens.rb" do
+                insert_into_file "config/screens.rb", :after => /Lanes::Screen.for_extension.*?\n/ do
                     source = File.expand_path(find_in_source_paths("config/screen.rb"))
                     ERB.new(::File.binread(source), nil, "-","@output_buffer").result(binding)
                 end
             end
+
+            ROOT_EL_FUNC = /rootComponent: \(viewport\) -> null/
+
+            def maybe_set_as_default
+                path = "#{client_dir}/Extension.coffee"
+                content = File.binread(path)
+                return unless content.match(ROOT_EL_FUNC)
+                content = "##=require ./screens/#{screen_id}\n\n" + content
+                content.gsub! ROOT_EL_FUNC, <<-LOADFN.strip_heredoc.chomp
+                              rootComponent: (viewport) ->
+                                      # render #{screen_class} by default.  If this is changed the
+                                      # ##=require ./screens/#{screen_id} at the top of file must also be updated
+                                      # to ensure that the correct screen's definition will be available at boot
+                                      #{screen_class}
+                    LOADFN
+                    File.open(path, "wb") { |file| file.write(content) }
+            end
         end
     end
 end

data/lib/lanes/command/generate_screen.usage

@@ -1,11 +1,8 @@
 Create the bare-bones definition of a screen
 
-Screens are a special type of view that have a few extra attributes.
-Namely, they have a "title" attribute and can be hidden and shown.  
+Screens are a special type of component that supports
+dynamic loading
 
-They are dynamically loaded.  Initially only the definition for the view
-is available, and the css and javascript for the view is only loaded
-when the view is first displayed.
-
-If the "model-class" option is provided, the screen will only be
-available to users who have read or write access to the given model.
+Initially only the definition for the screen is available,
+and the css and javascript for the it is loaded
+when the screen is first displayed.

data/lib/lanes/configuration.rb

@@ -12,7 +12,7 @@ module Lanes
         def self.config_option( name, default, options={} )
             define_method( "#{name}=" ) do | value |
                 old_value = self.send( name )
-                if old_value && Lanes.logger && !options[:silent]
+                if old_value && !options[:silent]
                     Lanes.logger.info "Config option #{name} changed from '#{old_value.inspect}' to '#{value.inspect}'"
                 end
                 instance_variable_set( "@#{name}", value )
@@ -58,7 +58,8 @@ module Lanes
         config_option :session_secret_key_base,  '1234', silent: true
 
         # Configuration for Redis
-        config_option :redis, { path: "/tmp/redis.sock" }
+        config_option :redis, ENV.has_key?('REDISTOGO_URL') ?
+           {url: ENV["REDISTOGO_URL"]} : {path: "/tmp/redis.sock"}
 
         # Title of application
         config_option :app_title, "Lanes Test"

data/lib/lanes/extension.rb

@@ -22,26 +22,19 @@ module Lanes
                 self.controlling_locked=true
             end
 
-            def load_after(extension)
-                self.after = extension
-            end
-
-            def load_before(extension)
-                self.before = extension
+            def add(klass)
+                @cached_instances = nil
+                if Extensions.controlling_locked
+                    ALL.unshift(klass)
+                else
+                    ALL << klass
+                end
             end
 
             def all
                 ALL
             end
 
-            def require_workspace?
-                all.any?{|ext| ext.uses_workspace }
-            end
-
-            def require_pub_sub?
-                all.any?{|ext| ext.uses_pub_sub }
-            end
-
             def each_asset(phase: :early, type: :js)
                 each do |ext|
                     if phase == :all || ext.load_phase == phase
@@ -80,13 +73,14 @@ module Lanes
             end
 
             def each
-                sorted.map{ |klass| yield klass.new }
+                @cached_instances ||= sorted.map{ |klass| klass.new }
+                @cached_instances.each{ |ext| yield ext }
             end
 
             def controlling
                 last = ALL.last
                 each{|ext| return ext if ext.is_a?(last) }
-                LanesExtension.new # fallback if can't find an extension
+                Lanes.logger.error "Unable to find controlling extension. #{sorted} are loaded"
             end
 
             def client_bootstrap_data(view)
@@ -98,10 +92,10 @@ module Lanes
                   api_path: Lanes.config.mounted_at,
                   environment: Lanes.config.environment,
                   initial_workspace_screen_id: Lanes.config.initial_workspace_screen_id,
-                  pub_sub: require_pub_sub?
                 }
                 each do | ext |
-                    data[ext.identifier] = ext.client_bootstrap_data(view)
+                    ext_data  = ext.client_bootstrap_data(view)
+                    data[ext.identifier] = ext_data unless ext_data.nil?
                 end
                 return data
             end

data/lib/lanes/extension/definition.rb

@@ -5,11 +5,7 @@ module Lanes
             include ::Lanes::Concerns::AttrAccessorWithDefault
 
             def self.inherited(klass)
-                if Extensions.controlling_locked
-                    ALL.unshift(klass)
-                else
-                    ALL << klass
-                end
+                Extensions.add(klass)
             end
 
             attr_reader :context
@@ -23,17 +19,27 @@ module Lanes
 
             attr_accessor_with_default :db_table_prefix
 
-            # Does the extension use PubSub functionality
-            class_attribute  :uses_pub_sub
-
             # Load extension before/after the named extensions
             class_attribute :before
             class_attribute :after
 
+
             def self.components(*names)
                 Components.enable(*names)
             end
 
+            def initialize
+                self.add_to_load_path
+            end
+
+            def load_after(extension)
+                self.after = extension
+            end
+
+            def load_before(extension)
+                self.before = extension
+            end
+
             def client_bootstrap_data(view)
                 {}
             end
@@ -80,6 +86,12 @@ module Lanes
             def on_boot
             end
 
+            def add_to_load_path
+                @in_load_path_set ||= (
+                    lib = root_path.join('lib').to_s
+                    $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+                )
+            end
         end
 
         class Base < Definition

data/lib/lanes/guard_tasks.rb

@@ -1,12 +1,15 @@
 require_relative "../lanes"
 require 'guard/jasmine'
 require 'guard/minitest'
+require "net/http"
+require "uri"
+require_relative "hot_reload_plugin"
 
 module Lanes
     module GuardTasks
 
         class CustomMatchers
-            attr_reader :client_matches, :server_matches
+            attr_reader :client_matches, :server_matches, :hot_reload
 
             def client(&block)
                 @client_matches = block
@@ -14,25 +17,39 @@ module Lanes
             def server(&block)
                 @server_matches = block
             end
+            def hot_reload(&block)
+                @hot_reload = 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 = options.merge({
-                port: 8888, server_mount: '/spec', server_env: 'test', server: :puma,
-                spec_dir: "spec/#{app_name}", console: :always, debug: false
+               port: 8888, server_mount: '/spec',
+               server_env: 'development',
+               server: :puma, spec_dir: "spec/#{app_name}",
+               console: :always, debug: false
             })
 
+
             minitest_options = {
               all_on_start: true, test_folders: 'spec/server'
             }
+            coffee_files = %r{^client/(.+?)\.(js|coffee|cjsx)$}
+
+            dsl.guard :hot_reload, port: jasmine_options[:port] do
+                dsl.watch(coffee_files)
+                dsl.watch(%r{\.scss$})
+                matchers.hot_reload.call if matchers.hot_reload
+            end
 
             dsl.guard :jasmine, jasmine_options do
-                dsl.watch(%r{^client/(.+?)\.(js|coffee)$}){ |m| "spec/#{m[1]}Spec.#{m[2]}" }
-                dsl.watch(%r{^spec/.*(?:_s|S)pec\.coffee$})
+                dsl.watch(coffee_files){ |m| "spec/#{m[0]}Spec.#{m[2]}" }
+                dsl.watch(%r{^spec/.*(?:_s|S)pec\.(?:js|coffee|cjsx)$}){|m| p m; m}
                 matchers.client_matches.call if matchers.client_matches
             end
 

data/lib/lanes/hot_reload_plugin.rb

@@ -0,0 +1,47 @@
+require 'guard/compat/plugin'
+module ::Guard
+
+    class HotReload < Plugin
+
+        def initialize(options = {})
+            super
+            @uri = URI.parse(
+                "http://localhost:#{options[:port]}/file-change.json"
+            )
+        end
+
+        def run_all
+        end
+
+        def asset_to_json(file)
+            file.gsub!(/client\//,'')
+            if file.match(/\.(js|coffee|cjsx)$/)
+                file.gsub!(/(.*)\.(js|coffee|cjsx)$/, '\1.js')
+                comp = file.split('/')#[1..-1]
+                comp[comp.length-1] = comp.last.gsub(/\.\w+$/,'')
+                { "type" => "js", "path" => file, "components" => comp }
+            else
+                path = if file.match(%r{/screens/.*/\w+\.scss})
+                           file.gsub(%r{/\w+.\w*css},'.css')
+                       else
+                           file
+                       end
+                { "type" => "css", "path" => path, "trigger" => file }
+            end
+
+        end
+
+        def run_on_modifications(paths)
+            post = Net::HTTP::Post.new(@uri.request_uri)
+            body = paths.map do | file |
+                asset_to_json(file)
+            end
+            p body
+            post.body = Oj.dump(body)
+            http = Net::HTTP.new(@uri.host, @uri.port)
+            http.request(post)
+        end
+
+    end
+
+end