lanes 0.8.2 → 0.8.3

data/lib/lanes/command/webpack.rb

@@ -0,0 +1,54 @@
+require 'forwardable'
+require 'fileutils'
+require 'pathname'
+
+module Lanes
+
+    module Command
+
+        class Webpack < Thor::Group
+            include Thor::Actions
+
+            attr_reader :process
+
+            attr_accessor :config
+
+            attr_reader :wpd_config
+
+            class_option :wait, :type => :boolean, default: true,
+                         desc: "Whether to keep running and wait for exit"
+
+            def make_config
+                return if @config
+                @config = ClientConfig.new
+                config.invoke_all
+            end
+
+            def configure
+                @wpd_config = WebpackDriver::Configuration.new(
+                    config.extension_path.join('config', 'webpack.config.js'),
+                    cmd_line_flags: ['--hot', '--inline'],
+                    logger: Lanes.logger,
+                    directory: config.controlling_extension.root_path
+                )
+
+                wpd_config.environment.merge!(
+                    EXTENSION_ID: config.controlling_extension.identifier,
+                    LANES_MODULES: config.module_paths.join(':'),
+                    ENTRY: 'show-maker/index.js',
+                    GENERATED_CONFIG_DIR: config.directory.to_s
+                )
+
+                self
+            end
+
+            def startup
+                @process = ::WebpackDriver::DevServer.new(wpd_config)
+                @process.start
+                @process.wait if options[:wait]
+            end
+
+        end
+    end
+
+end

data/lib/lanes/extension.rb

@@ -17,13 +17,6 @@ module Lanes
                 end
             end
 
-            def asset_paths(controller, additional)
-                map { |ext| ext.root_path.join('client').to_s }.reverse + [
-                    controller.root_path.join('node_modules').to_s,
-                    additional
-                ]
-            end
-
             # lock the current controlling extension so that it can't
             # be changed by other extensions that are loaded later
             def lock_controlling!

data/lib/lanes/guard_tasks.rb

@@ -1,19 +1,15 @@
-require_relative "../lanes"
-# require 'guard/jasmine'
-require "guard/jest"
-require 'guard/minitest'
-require "net/http"
-require "uri"
-# require_relative "lanes_guard_plugin"
-
-# require_relative "hot_reload_plugin"
+require_relative '../lanes'
 require_relative 'command/jest'
+require_relative 'reloadable_sinatra.rb'
+require 'guard/jest'
+require 'guard/rspec'
 
 module Lanes
     module GuardTasks
+        mattr_accessor :client_config
 
         class CustomMatchers
-            attr_reader :client_matches, :server_matches#, :hot_reload
+            attr_reader :client_matches, :server_matches
 
             def client(&block)
                 @client_matches = block
@@ -29,27 +25,32 @@ module Lanes
             matchers = CustomMatchers.new
             yield matchers
 
+            config = client_config || ::Lanes::Command::Jest.new.configure.config
+
             jest_options = options.merge(
                 logger: Lanes.logger,
                 silent: false,
                 jest_cmd: './node_modules/.bin/jest',
-                config_file: ::Lanes::Command::Jest.new.configure.config_file
+                config_file: config.directory.join('jest.config.json')
             )
-
             dsl.guard :jest, jest_options
 
-
-            minitest_options = {
-              all_on_start: false, test_folders: 'spec/server'
+            rspec_options = {
+                all_on_start: false,
+                cmd: 'bundle exec rspec'
             }
-            dsl.guard :minitest, minitest_options do
-                dsl.watch(%r{^spec/server/spec_helper\.rb}) { 'test' }
+            dsl.guard :rspec, rspec_options do
+#                dsl.watch(%r{^spec/server/spec_helper\.rb}) { 'spec' }
                 dsl.watch(%r{^spec/server/.*_spec\.rb})
-                dsl.watch(%r{^spec/fixtures/#{app_name}/(.+)s\.yml})   { |m| "spec/server/#{m[1]}_spec.rb" }
-                dsl.watch(%r{^lib/#{app_name}/(.+)\.rb})               { |m| "spec/server/#{m[1]}_spec.rb" }
-                matchers.server_matches.call if matchers.server_matches
+                # dsl.watch(%r{^spec/fixtures/#{app_name}/(.+)s\.yml})   { |m| "spec/server/#{m[1]}_spec.rb" }
+                # dsl.watch(%r{^lib/#{app_name}/(.+)\.rb})               { |m| "spec/server/#{m[1]}_spec.rb" }
+                # matchers.server_matches.call if matchers.server_matches
             end
 
+            dsl.guard :reloadable_sinatra do
+                dsl.watch(%r{^lib/.*\.rb})
+
+            end
         end
 
     end

data/lib/lanes/rake_tasks.rb

@@ -1,12 +1,21 @@
 require 'puma/control_cli'
 require 'resque/tasks'
 require_relative '../lanes'
+require_relative 'command/jest'
 
 desc "Run the puma server in development mode"
 task :dev do
     Puma::ControlCLI.new(['start']).run
 end
 
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+      t.pattern = Dir.glob('spec/server/**/*_spec.rb')
+  end
+rescue LoadError
+end
+
 desc "Open an irb session configured with the Lanes environment"
 task :console do
     require 'irb'
@@ -53,3 +62,7 @@ namespace :assets do
         Lanes::API::SprocketsExtension.compile!
     end
 end
+
+task :test => [:spec] do
+    ::Lanes::Command::Jest.new.configure.single_run
+end

data/lib/lanes/reloadable_sinatra.rb

@@ -0,0 +1,24 @@
+require 'guard/compat/plugin'
+require_relative 'command/puma'
+
+module ::Guard
+
+    class ReloadableSinatra < ::Guard::Plugin
+        def start
+            puts "RELOAD"
+            @puma = ::Lanes::Command::Puma.new
+            @puma.start
+        end
+
+        def run_on_modifications(paths)
+            @puma.stop
+            @puma.start
+        end
+
+        def stop
+            @puma.stop
+        end
+
+    end
+
+end

data/lib/lanes/screen.rb

@@ -15,14 +15,17 @@ module Lanes
             end
 
             def define(id)
-                definition = ( DEFINITIONS[id] ||= Definition.new(id, @extension_id) )
+                definition = (DEFINITIONS[id] ||= Definition.new(id, @extension_id))
                 yield definition
             end
         end
 
         class << self
+
+            include Enumerable
+
             def [](config)
-                if DEFINITIONS.has_key?(config)
+                if DEFINITIONS.key?(config)
                     DEFINITIONS[config]
                 else
                     nil
@@ -49,12 +52,9 @@ module Lanes
             end
 
             def config_file
-                Lanes::Extensions.controlling.root_path.join("config","screens.rb")
+                Lanes::Extensions.controlling.root_path.join("config", "screens.rb")
             end
 
-            def uncache_file_on_update(asset)
-                asset.depend_on(config_file) if config_file.exist?
-            end
         end
 
 
@@ -96,6 +96,10 @@ module Lanes
                 @extension    = extension_id.underscore.camelize
             end
 
+            def group
+                GROUPS[@group_id]
+            end
+
             def has_file_matching?(pattern)
                 Pathname.glob(root_path.join(pattern)).any?
             end
@@ -106,6 +110,11 @@ module Lanes
                 ext.root_path.join('client', url_prefix, identifier)
             end
 
+            def model
+                ext = Lanes::Extensions.for_identifier(@extension_id)
+                (@extension_id.camelize + '::' + @model_class).constantize
+            end
+
             def as_json
                 {
                     id:    identifier,

data/lib/lanes/spec_helper.rb

@@ -1,154 +1,88 @@
-require 'minitest/autorun'
 require 'rack/test'
 require 'lanes'
 require 'lanes/api'
 require 'hashie/mash'
 require 'active_record'
 require 'active_record/fixtures'
-require 'minitest/around/unit'
-require 'minitest/around/spec'
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'mocha/mini_test'
 
 LANES_ENV = "test"
-I18n.enforce_available_locales = true
-Lanes::DB.establish_connection
-Lanes.logger = Logger.new(
-    File.open('log/test.log', File::WRONLY | File::APPEND | File::CREAT )
-)
-ActiveRecord::Base.logger = Lanes.logger
-ActiveSupport::Dependencies.mechanism = :require
-ActiveSupport.test_order = :random
 
-module Lanes
+RSpec.configure do |config|
 
-    class DummyUser
-        def can_read?(*args)
-            true
-        end
-        def can_write?(*args)
-            true
-        end
-        def can_delete?(*args)
-            true
-        end
-    end
-
-    class TestCase < ActiveSupport::TestCase
-        include Lanes
-
-        include ActiveRecord::TestFixtures
-        self.fixture_path = Lanes::Extensions.controlling.root_path.join('spec','fixtures')
 
-        self.use_transactional_tests = true
-        fixtures :all
+    # Use color in STDOUT
+    config.color = true
 
-        def admin
-            lanes_users(:admin)
-        end
-
-        extend MiniTest::Spec::DSL
-        register_spec_type self do |desc|
-            desc < Lanes::Model if desc.is_a? Class
-        end
 
+    # rspec-expectations config goes here. You can use an alternate
+    # assertion/expectation library such as wrong or the stdlib/minitest
+    # assertions if you prefer.
+    config.expect_with :rspec do |expectations|
+        # This option will default to `true` in RSpec 4. It makes the `description`
+        # and `failure_message` of custom matchers include text for helper methods
+        # defined using `chain`, e.g.:
+        #     be_bigger_than(2).and_smaller_than(4).description
+        #     # => "be bigger than 2 and smaller than 4"
+        # ...rather than:
+        #     # => "be bigger than 2"
+        expectations.include_chain_clauses_in_custom_matcher_descriptions = true
     end
 
-    class ApiTestCase < TestCase
-        include Rack::Test::Methods
-
-        teardown do
-            @current_user = nil
-        end
-
-        def app
-            Lanes::API::Root.new
-        end
-
-        def json_body
-            Hashie::Mash.new Oj.load( last_response.body )
-        end
-
-        def json_data
-            json_body['data']
-        end
-
-        [ :delete, :get ].each do |name|
-            define_method(name) do |uri, params = {}, env = {}, &block|
-                session = env['rack.session'] ||= {}
-                session[:user_id] = @current_user.id if @current_user
-                params.stringify_keys!
-                super(uri, params, env, &block)
-            end
-        end
-
-        [ :put, :post, :patch].each do |name|
-            define_method(name) do |uri, params = {}, env = {}, &block|
-                session = env['rack.session'] ||= {}
-                session[:user_id] = @current_user.id if @current_user
-                params = Oj.dump(params, mode: :compat) if params.is_a?(Hash)
-                super(uri, params, env, &block)
-            end
-        end
-
-        def login!(user=admin)
-            @current_user = user
-        end
-
-        def assert_ok
-            assert last_response.ok?, "Request failed with #{last_response.status}"
-        end
-        def refute_ok
-            refute last_response.ok?, "Request succeeded with status #{last_response.status}, expected non-2XX"
-        end
+    # rspec-mocks config goes here. You can use an alternate test double
+    # library (such as bogus or mocha) by changing the `mock_with` option here.
+    config.mock_with :rspec do |mocks|
+        # Prevents you from mocking or stubbing a method that does not exist on
+        # a real object. This is generally recommended, and will default to
+        # `true` in RSpec 4.
+        mocks.verify_partial_doubles = true
     end
-end
-
-module MiniTest
-    module Assertions
-
-        def assert_logs_matching( regex, failure_message=nil, &block )
-            old_logger = Lanes.logger
-            begin
-                output = ""
-                Lanes.logger=Logger.new( StringIO.new(output) )
-                yield
-                assert_match( regex, output, failure_message )
-            ensure
-                Lanes.logger=old_logger
-            end
-        end
-
-
-        def assert_saves( model )
-            assert model.save, "#{model.class} failed to save: #{model.errors.full_messages.join(',')}"
-        end
-
-        def refute_saves( model, *errors )
-            refute model.save, "#{model.class} saved successfully when it should not have"
-            errors.each do |error|
-                if model.errors[error.to_sym].empty?
-                    raise MiniTest::Assertion, "expected #{model.class} to have an error on #{error}"
-                end
-            end
 
-        end
-
-        def assert_event_fires( klass, event, &block )
-            @event_results = []
-            klass.observe(event) do | *args |
-                @event_results = args
-            end
-            yield
-            raise MiniTest::Assertion, "Event #{event} was not fired" if @event_results.empty?
-        end
-
-        def last_event_results
-            @event_results
-        end
-    end
+    # The settings below are suggested to provide a good initial experience
+    # with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
 end
-
-
-require_relative 'access/test_fixture_extensions'