js_rails_routes 0.7.0 → 0.7.1

data/spec/js_rails_routes/generator_spec.rb

@@ -1,199 +1,30 @@
 # frozen_string_literal: true
 
 RSpec.describe JSRailsRoutes::Generator do
-  let(:generator) do
-    described_class.clone.instance
-  end
+  include_context 'run in a sandbox'
+
+  subject(:generator) { described_class.new(builder, writable: writable) }
 
-  it { expect(described_class).to include(Singleton) }
+  let(:writable) { spy('writable') }
+  let(:builder) { double('builder', build: result) }
+  let(:result) { Hash['Rails' => 'rails body', 'Admin::Engine' => 'admin body'] }
 
   describe '#generate' do
-    let(:output_dir) { File.expand_path('spec/tmp') }
-    subject do
-      generator.output_dir = output_dir
-      generator.generate(task)
-    end
+    subject { generator.generate(task) }
 
-    let(:task) do
-      'js:routes'
-    end
+    let(:task) { 'js:routes' }
 
-    it 'writes JS files' do
-      expect(generator).to receive(:write)
-        .with(be_in(['Rails', 'Admin::Engine']), a_string_including("rake #{task}"))
-        .twice
+    it 'writes with path to file and its contents' do
+      allow(writable).to receive(:write)
       subject
-    end
-
-    context 'when actually creating files' do
-      let(:js_files) { Dir.glob(File.join(output_dir, '{admin,rails}-routes.js')).map { |file| Pathname.new(file) } }
-
-      after { FileUtils.rm_f(js_files) }
-
-      it 'creates JS files' do
-        subject
-        expect(js_files).to all be_file
-      end
-    end
-
-    context 'when include_paths is given' do
-      before do
-        generator.include_paths = include_paths
-      end
-
-      let(:include_paths) do
-        %r{/new}
-      end
-
-      it 'writes paths matching with the parameter' do
-        expect(generator).to receive(:write)
-          .with(be_in(['Rails', 'Admin::Engine']), a_kind_of(String))
-          .twice do |_, arg|
-            paths = arg.split("\n")[(2 + described_class::PROCESS_FUNC.split("\n").size)..-1]
-            expect(paths).not_to be_empty
-            expect(paths).to all(match(include_paths))
-          end
-        subject
-      end
-    end
-
-    context 'when exclude_paths is given' do
-      before do
-        generator.exclude_paths = exclude_paths
-      end
-
-      let(:exclude_paths) do
-        %r{/new}
-      end
-
-      it 'writes paths not matching with the parameter' do
-        expect(generator).to receive(:write)
-          .with(be_in(['Rails', 'Admin::Engine']), a_kind_of(String))
-          .twice do |_, arg|
-            paths = arg.split("\n")[(2 + described_class::PROCESS_FUNC.split("\n").size)..-1]
-            expect(paths).not_to be_empty
-            paths.each do |path|
-              expect(path).to_not match(exclude_paths)
-            end
-          end
-        subject
-      end
-    end
-
-    context 'when include_names is given' do
-      before do
-        generator.include_names = include_names
-      end
-
-      let(:include_names) do
-        /user|note/
-      end
-
-      it 'writes paths matching with the parameter' do
-        expect(generator).to receive(:write)
-          .with(be_in(['Rails', 'Admin::Engine']), a_kind_of(String))
-          .twice do |_, arg|
-            paths = arg.split("\n")[(2 + described_class::PROCESS_FUNC.split("\n").size)..-1]
-            expect(paths).not_to be_empty
-            expect(paths).to all(match(include_names))
-          end
-        subject
-      end
-    end
-
-    context 'when exclude_names is given' do
-      before do
-        generator.exclude_names = exclude_names
-      end
-
-      let(:exclude_names) do
-        /user|note/
-      end
-
-      it 'writes paths not matching with the parameter' do
-        expect(generator).to receive(:write)
-          .with(be_in(['Rails', 'Admin::Engine']), a_kind_of(String))
-          .twice do |_, arg|
-            paths = arg.split("\n")[(2 + described_class::PROCESS_FUNC.split("\n").size)..-1]
-            expect(paths).not_to be_empty
-            paths.each do |path|
-              expect(path).to_not match(exclude_names)
-            end
-          end
-        subject
-      end
-    end
-
-    context 'when exclude_engines is given' do
-      before do
-        generator.exclude_engines = exclude_engines
-      end
-
-      let(:exclude_engines) do
-        /^admin/
-      end
-
-      let(:excluded_routes) do
-        /note|photo/
-      end
-
-      it 'writes paths not matching with the parameter' do
-        expect(generator).to receive(:write)
-          .with(be_in(['Rails', 'Admin::Engine']), a_kind_of(String))
-          .once do |_, arg|
-            paths = arg.split("\n")[(2 + described_class::PROCESS_FUNC.split("\n").size)..-1]
-            expect(paths).not_to be_empty
-            paths.each do |path|
-              expect(path).to_not match(excluded_routes)
-            end
-          end
-        subject
-      end
-    end
-
-    shared_examples_for 'writes paths that matches expected routes' do
-      it do
-        expect(generator).to receive(:write)
-          .with(be_in(['Rails', 'Admin::Engine']), a_kind_of(String))
-          .twice do |_, arg|
-            paths = arg.split("\n")[(2 + described_class::PROCESS_FUNC.split("\n").size)..-1]
-            expect(paths).not_to be_empty
-            expect(paths).to include(match(expected_routes))
-          end
-        subject
-      end
-    end
-
-    context 'when camelize is nil' do
-      let(:expected_routes) do
-        /blog_path|note_path/
-      end
-
-      it_behaves_like 'writes paths that matches expected routes'
-    end
-
-    context 'when camelize is :lower' do
-      before do
-        generator.camelize = :lower
-      end
-
-      let(:expected_routes) do
-        /blogPath|notePath/
-      end
-
-      it_behaves_like 'writes paths that matches expected routes'
-    end
-
-    context 'when camelize is :upper' do
-      before do
-        generator.camelize = :upper
-      end
-
-      let(:expected_routes) do
-        /BlogPath|NotePath/
-      end
-
-      it_behaves_like 'writes paths that matches expected routes'
+      expect(writable).to have_received(:write).with(
+        a_string_ending_with('app/assets/javascripts/rails-routes.js'),
+        a_string_including('rails body')
+      ).ordered
+      expect(writable).to have_received(:write).with(
+        a_string_ending_with('app/assets/javascripts/admin-routes.js'),
+        a_string_including('admin body')
+      ).ordered
     end
   end
 end

data/spec/js_rails_routes/language/base_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe JSRailsRoutes::Language::Base do
+  subject(:language) { described_class.new }
+
+  describe '#handle_route_set' do
+    subject { language.handle_route_set(double('route set')) }
+
+    it { expect { subject }.to raise_error(NotImplementedError) }
+  end
+end

data/spec/js_rails_routes/language/javascript_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+RSpec.describe JSRailsRoutes::Language::JavaScript do
+  subject(:language) { described_class.new }
+
+  include_context 'run in a sandbox'
+
+  describe '::PROCESS_FUNC' do
+    subject { described_class::PROCESS_FUNC }
+
+    it 'returns a javascript function' do
+      is_expected.to eq <<~JAVASCRIPT
+        function process(route, params, keys) {
+          var query = [];
+          for (var param in params) if (params.hasOwnProperty(param)) {
+            if (keys.indexOf(param) === -1) {
+              query.push(param + "=" + encodeURIComponent(params[param]));
+            }
+          }
+          return query.length ? route + "?" + query.join("&") : route;
+        }
+      JAVASCRIPT
+    end
+  end
+
+  describe '#handle_route_set' do
+    subject { language.handle_route_set(route_set) }
+
+    let(:route_set) do
+      rails_route_set = ActionDispatch::Routing::RouteSet.new.tap do |routes|
+        routes.draw do
+          resources :articles
+        end
+      end
+      JSRailsRoutes::RouteSet.new('Rails', rails_route_set)
+    end
+
+    context 'without camelize option' do
+      it 'returns a javascript with snake_case functions' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function articles_path(params) { return process('/articles', params, []); }
+          export function new_article_path(params) { return process('/articles/new', params, []); }
+          export function edit_article_path(params) { return process('/articles/' + params.id + '/edit', params, ['id']); }
+          export function article_path(params) { return process('/articles/' + params.id + '', params, ['id']); }
+        JAVASCRIPT
+      end
+    end
+
+    context 'with camelize = :lower option' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.camelize = :lower
+        end
+      end
+
+      it 'returns a javascript with lowerCamelCase functions' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function articlesPath(params) { return process('/articles', params, []); }
+          export function newArticlePath(params) { return process('/articles/new', params, []); }
+          export function editArticlePath(params) { return process('/articles/' + params.id + '/edit', params, ['id']); }
+          export function articlePath(params) { return process('/articles/' + params.id + '', params, ['id']); }
+        JAVASCRIPT
+      end
+    end
+
+    context 'with camelize = :upper option' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.camelize = :upper
+        end
+      end
+
+      it 'returns a javascript with UpperCamelCase functions' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function ArticlesPath(params) { return process('/articles', params, []); }
+          export function NewArticlePath(params) { return process('/articles/new', params, []); }
+          export function EditArticlePath(params) { return process('/articles/' + params.id + '/edit', params, ['id']); }
+          export function ArticlePath(params) { return process('/articles/' + params.id + '', params, ['id']); }
+        JAVASCRIPT
+      end
+    end
+
+    context 'with include_paths option' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.include_paths = /new/
+        end
+      end
+
+      it 'returns a javascript matching to the regexp' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function new_article_path(params) { return process('/articles/new', params, []); }
+        JAVASCRIPT
+      end
+    end
+
+    context 'with exclude_paths option' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.exclude_paths = /new/
+        end
+      end
+
+      it 'returns a javascript not matching to the regexp' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function articles_path(params) { return process('/articles', params, []); }
+          export function edit_article_path(params) { return process('/articles/' + params.id + '/edit', params, ['id']); }
+          export function article_path(params) { return process('/articles/' + params.id + '', params, ['id']); }
+        JAVASCRIPT
+      end
+    end
+
+    context 'with include_names option' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.include_names = /new/
+        end
+      end
+
+      it 'returns a javascript matching to the regexp' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function new_article_path(params) { return process('/articles/new', params, []); }
+        JAVASCRIPT
+      end
+    end
+
+    context 'with exclude_names option' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.exclude_names = /new/
+        end
+      end
+
+      it 'returns a javascript not matching to the regexp' do
+        is_expected.to eq <<~JAVASCRIPT
+          #{described_class::PROCESS_FUNC}
+          export function articles_path(params) { return process('/articles', params, []); }
+          export function edit_article_path(params) { return process('/articles/' + params.id + '/edit', params, ['id']); }
+          export function article_path(params) { return process('/articles/' + params.id + '', params, ['id']); }
+        JAVASCRIPT
+      end
+    end
+  end
+end

data/spec/js_rails_routes/route_set_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+RSpec.describe JSRailsRoutes::RouteSet do
+  subject(:route_set) { described_class.new(name, routes) }
+
+  include_context 'run in a sandbox'
+
+  let(:name) { 'Foo::Engine' }
+  let(:routes) do
+    ActionDispatch::Routing::RouteSet.new.tap do |routes|
+      routes.draw do
+        get '/articles' => 'articles#index'
+        get '/users' => 'users#index'
+      end
+    end
+  end
+
+  describe '.correct_matching_route_set_list' do
+    subject { described_class.correct_matching_route_set_list }
+
+    it 'returns an array of matching route sets' do
+      # See spec/support/test_app.rb
+      is_expected.to match [
+        be_a(described_class).and(have_attributes(name: 'Rails')).and(be_match),
+        be_a(described_class).and(have_attributes(name: 'Admin::Engine')).and(be_match)
+      ]
+    end
+  end
+
+  describe '#name' do
+    subject { route_set.name }
+
+    it { is_expected.to eq name }
+  end
+
+  describe '#routes' do
+    subject { route_set.routes }
+
+    it { is_expected.to all be_a(JSRailsRoutes::Route).and(be_match) }
+
+    context 'when some routes are excluded' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.exclude_names = /users/
+        end
+      end
+
+      it "doesn't include the excluded route" do
+        is_expected.to include be_a(JSRailsRoutes::Route).and(have_attributes(name: /articles/))
+        is_expected.not_to include be_a(JSRailsRoutes::Route).and(have_attributes(name: /users/))
+      end
+    end
+  end
+
+  describe '#match?' do
+    subject { route_set.match? }
+
+    it { is_expected.to be true }
+
+    context 'when exclude_engines option is specified' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.exclude_engines = exclude_engines
+        end
+      end
+
+      context 'and it matches to the name' do
+        let(:exclude_engines) { /Foo/ }
+
+        it { is_expected.to be false }
+      end
+
+      context 'and it does not match to the name' do
+        let(:exclude_engines) { /Bar/ }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context 'when routes are empty' do
+      before { allow(route_set).to receive(:routes).and_return([]) }
+
+      it { is_expected.to be false }
+    end
+  end
+end

data/spec/js_rails_routes/route_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+RSpec.describe JSRailsRoutes::Route do
+  subject(:route) { described_class.new(raw_route) }
+
+  include_context 'run in a sandbox'
+
+  let(:raw_route) do
+    ActionDispatch::Routing::RouteSet.new.tap do |routes|
+      routes.draw do
+        get '/articles' => 'articles#index'
+      end
+    end.routes.first
+  end
+
+  describe '#name' do
+    subject { route.name }
+
+    it { is_expected.to eq 'articles' }
+  end
+
+  describe '#path' do
+    subject { route.path }
+
+    it { is_expected.to eq '/articles' }
+  end
+
+  describe '#match?' do
+    subject { route.match? }
+
+    it { is_expected.to be true }
+
+    context 'when include_paths option is specified' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.include_paths = include_paths
+        end
+      end
+
+      context 'and it matches to the path' do
+        let(:include_paths) { /articles/ }
+
+        it { is_expected.to be true }
+      end
+
+      context 'and it does not matche to the path' do
+        let(:include_paths) { /users/ }
+
+        it { is_expected.to be false }
+      end
+    end
+
+    context 'when exclude_paths option is specified' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.exclude_paths = exclude_paths
+        end
+      end
+
+      context 'and it matches to the path' do
+        let(:exclude_paths) { /articles/ }
+
+        it { is_expected.to be false }
+      end
+
+      context 'and it does not matche to the path' do
+        let(:exclude_paths) { /users/ }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context 'when include_names option is specified' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.include_names = include_names
+        end
+      end
+
+      context 'and it matches to the name' do
+        let(:include_names) { /articles/ }
+
+        it { is_expected.to be true }
+      end
+
+      context 'and it does not matche to the name' do
+        let(:include_names) { /users/ }
+
+        it { is_expected.to be false }
+      end
+    end
+
+    context 'when exclude_names option is specified' do
+      before do
+        JSRailsRoutes.configure do |c|
+          c.exclude_names = exclude_names
+        end
+      end
+
+      context 'and it matches to the name' do
+        let(:exclude_names) { /articles/ }
+
+        it { is_expected.to be false }
+      end
+
+      context 'and it does not matche to the name' do
+        let(:exclude_names) { /users/ }
+
+        it { is_expected.to be true }
+      end
+    end
+  end
+end

data/spec/js_rails_routes_spec.rb

@@ -2,8 +2,67 @@
 
 RSpec.describe JSRailsRoutes do
   describe '.configure' do
-    it 'yields with Generator instance' do
-      expect { |b| described_class.configure(&b) }.to yield_with_args(JSRailsRoutes::Generator.instance)
+    it 'yields with .config' do
+      expect { |b| described_class.configure(&b) }.to yield_with_args(described_class.config)
+    end
+  end
+
+  describe '.config' do
+    subject { described_class.config }
+
+    it { is_expected.to be_a JSRailsRoutes::Configuration }
+  end
+
+  describe '.sandbox' do
+    it 'yields within a new sandbox' do
+      original = described_class.config
+      described_class.sandbox do
+        expect(described_class.config).not_to be original
+        expect(described_class.config).to be_a JSRailsRoutes::Configuration
+      end
+      expect(described_class.config).to be original
+    end
+  end
+
+  describe '.generate_javascript' do
+    subject { described_class.generate_javascript(task) }
+
+    let(:task) { 'js:routes' }
+    let(:app_root) { JSRailsRoutes::SpecHelper::TestApp.root }
+
+    before do
+      FileUtils.rm_rf(app_root)
+      FileUtils.mkdir_p(app_root.join('app/assets/javascripts'))
+    end
+
+    it 'generates javascript files' do
+      subject
+
+      expect(File.read(app_root.join('app/assets/javascripts/rails-routes.js'))).to eq <<~JAVASCRIPT
+        // Don't edit manually. `rake #{task}` generates this file.
+        #{JSRailsRoutes::Language::JavaScript::PROCESS_FUNC}
+        export function blogs_path(params) { return process('/blogs', params, []); }
+        export function new_blog_path(params) { return process('/blogs/new', params, []); }
+        export function edit_blog_path(params) { return process('/blogs/' + params.id + '/edit', params, ['id']); }
+        export function blog_path(params) { return process('/blogs/' + params.id + '', params, ['id']); }
+        export function users_path(params) { return process('/users', params, []); }
+        export function new_user_path(params) { return process('/users/new', params, []); }
+        export function edit_user_path(params) { return process('/users/' + params.id + '/edit', params, ['id']); }
+        export function user_path(params) { return process('/users/' + params.id + '', params, ['id']); }
+      JAVASCRIPT
+
+      expect(File.read(app_root.join('app/assets/javascripts/admin-routes.js'))).to eq <<~JAVASCRIPT
+        // Don't edit manually. `rake #{task}` generates this file.
+        #{JSRailsRoutes::Language::JavaScript::PROCESS_FUNC}
+        export function notes_path(params) { return process('/notes', params, []); }
+        export function new_note_path(params) { return process('/notes/new', params, []); }
+        export function edit_note_path(params) { return process('/notes/' + params.id + '/edit', params, ['id']); }
+        export function note_path(params) { return process('/notes/' + params.id + '', params, ['id']); }
+        export function photos_path(params) { return process('/photos', params, []); }
+        export function new_photo_path(params) { return process('/photos/new', params, []); }
+        export function edit_photo_path(params) { return process('/photos/' + params.id + '/edit', params, ['id']); }
+        export function photo_path(params) { return process('/photos/' + params.id + '', params, ['id']); }
+      JAVASCRIPT
     end
   end
 end

data/spec/spec_helper.rb

@@ -8,23 +8,7 @@ SimpleCov.start
 require 'rails/all'
 require 'js_rails_routes'
 
-class TestApp < Rails::Application
-  config.root = File.expand_path('test_app', __dir__)
-
-  routes.draw do
-    resources :blogs
-    resources :users
-  end
-end
-
-module Admin
-  class Engine < ::Rails::Engine
-    routes.draw do
-      resources :notes
-      resources :photos
-    end
-  end
-end
+Dir[File.expand_path('support/**/*.rb', __dir__)].each { |f| require f }
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expectations|

data/spec/support/matchers/not_change.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+RSpec::Matchers.define_negated_matcher(:not_change, :change)

data/spec/support/shared_contexts/run_in_a_sandbox.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.shared_context 'run in a sandbox' do # rubocop:disable RSpec/ContextWording
+  around do |example|
+    JSRailsRoutes.sandbox { example.run }
+  end
+end