js_rails_routes 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a386d5fc5aec380f0c1747daa37cf0f8da385881
-  data.tar.gz: 22e8b29009a14466642bd32795c8aeab3d0a9b0b
+  metadata.gz: 1768a1c21e72db96adfed68e4e68cf5ba15a2ad2
+  data.tar.gz: cecbb2cbd58e60f4e0449dcd12b8c903d1aa65bc
 SHA512:
-  metadata.gz: '087716b33ddff3babd4d84cbf6c70ab39bbc5d2c766bb2ae4af803ac74fcbacb2e22e0fdc035811bce993f1f281193250184d6ec7f0e37b55b302ab2cfc8713e'
-  data.tar.gz: a75bd8bd4df03ff80cf8d5dc39c6275923b539d8805933f3f1ffa0c3111470d474db3408c3f022e72f9475f2d6d99dfcc6744aa2d888939ba15d5736b5bf8835
+  metadata.gz: d599a65ae0bb2396c780f13c9cfee5a9431fd8c7e4c5ff1b5d6319c0f8650ea8db8db20b504f22e67c03357181b44d5c9a9a3aefe5cc56c5009120ea691a0fde
+  data.tar.gz: 06c1288cbf4107240254dbef471fca09b1d81a60301cf6c0a5a2b6ccb5a07eecdf3d731ab3628b3c265c930b623aefc951e887f71b2b936ccc0d410e784de272

data/.rubocop.yml

@@ -1,3 +1,6 @@
+require:
+  - rubocop-rspec
+
 AllCops:
   TargetRubyVersion: 2.3
 
@@ -10,3 +13,33 @@ Metrics/BlockLength:
 
 Style/Documentation:
   Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  Exclude:
+  - 'spec/**/*'
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/NamedSubject:
+  Enabled: false
+
+RSpec/VerifiedDoubles:
+  Enabled: false
+
+RSpec/NestedGroups:
+  Max: 4
+
+RSpec/ContextWording:
+  Prefixes:
+    - when
+    - with
+    - without
+    - if
+    - and
+
+RSpec/FilePath:
+  Enabled: false

data/CHANGELOG.md

@@ -6,6 +6,9 @@ This change log adheres to [keepachangelog.com](http://keepachangelog.com).
 
 ## [Unreleased]
 
+## [0.7.1] - 2018-07-26
+- Refactor whole code base
+
 ## [0.7.0] - 2018-07-11
 ### Added
 - Support `camelize` option
@@ -51,7 +54,8 @@ This change log adheres to [keepachangelog.com](http://keepachangelog.com).
 ### Added
 - Implement "js:rails:routes" task
 
-[Unreleased]: https://github.com/yuku-t/js_rails_routes/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/yuku-t/js_rails_routes/compare/v0.7.1...HEAD
+[0.7.1]: https://github.com/yuku-t/js_rails_routes/compare/v0.7.0...v0.7.1
 [0.7.0]: https://github.com/yuku-t/js_rails_routes/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/yuku-t/js_rails_routes/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/yuku-t/js_rails_routes/compare/v0.4.0...v0.5.0

data/Gemfile

@@ -2,3 +2,5 @@
 
 source 'https://rubygems.org'
 gemspec
+
+gem 'pry'

data/README.md

@@ -1,10 +1,10 @@
 # rake js:routes
 
 [![Gem](https://img.shields.io/gem/v/js_rails_routes.svg?maxAge=2592000)](https://rubygems.org/gems/js_rails_routes)
-[![Build Status](https://travis-ci.org/yuku-t/js_rails_routes.svg?branch=master)](https://travis-ci.org/yuku/js_rails_routes)
-[![Code Climate](https://codeclimate.com/github/yuku-t/js_rails_routes/badges/gpa.svg)](https://codeclimate.com/github/yuku/js_rails_routes)
-[![Test Coverage](https://codeclimate.com/github/yuku-t/js_rails_routes/badges/coverage.svg)](https://codeclimate.com/github/yuku/js_rails_routes/coverage)
-[![license](https://img.shields.io/github/license/yuku-t/js_rails_routes.svg?maxAge=2592000)](https://github.com/yuku/js_rails_routes/blob/master/LICENSE)
+[![Build Status](https://travis-ci.org/yuku/js_rails_routes.svg?branch=master)](https://travis-ci.org/yuku/js_rails_routes)
+[![Code Climate](https://codeclimate.com/github/yuku/js_rails_routes/badges/gpa.svg)](https://codeclimate.com/github/yuku/js_rails_routes)
+[![Test Coverage](https://codeclimate.com/github/yuku/js_rails_routes/badges/coverage.svg)](https://codeclimate.com/github/yuku/js_rails_routes/coverage)
+[![license](https://img.shields.io/github/license/yuku/js_rails_routes.svg?maxAge=2592000)](https://github.com/yuku/js_rails_routes/blob/master/LICENSE)
 [![Analytics](https://ga-beacon.appspot.com/UA-4932407-14/js_rails_routes/readme)](https://github.com/igrigorik/ga-beacon)
 
 Generate a ES6 module that contains Rails routes.

data/js_rails_routes.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'codeclimate-test-reporter', '~> 1.0'
   spec.add_development_dependency 'rake', '~> 12.3'
   spec.add_development_dependency 'rspec', '~> 3.7'
-  spec.add_development_dependency 'rubocop', '~> 0.57.2'
+  spec.add_development_dependency 'rubocop', '~> 0.58.1'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.27'
   spec.add_development_dependency 'simplecov', '~> 0.16.1'
 end

data/lib/js_rails_routes/builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'js_rails_routes/route_set'
+
+module JSRailsRoutes
+  class Builder
+    # @return [Array<JSRailsRoutes::RouteSet>]
+    attr_reader :route_set_list
+
+    # @return [JSRailsRoutes::Language::Base]
+    attr_reader :language
+
+    # @param language [JSRailsRoutes::Language::Base]
+    # @param route_set_list [Array<JSRailsRoutes::RouteSet>]
+    def initialize(language, route_set_list = RouteSet.correct_matching_route_set_list)
+      @language = language
+      @route_set_list = route_set_list
+    end
+
+    # @return [Hash{String => String}]
+    def build
+      route_set_list.each_with_object({}) do |route_set, memo|
+        memo[route_set.name] = language.handle_route_set(route_set)
+      end
+    end
+  end
+end

data/lib/js_rails_routes/configuration.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JSRailsRoutes
+  class Configuration
+    attr_accessor :include_paths,
+                  :exclude_paths,
+                  :include_names,
+                  :exclude_names,
+                  :exclude_engines,
+                  :output_dir,
+                  :camelize
+
+    def initialize
+      self.include_paths = /.*/
+      self.exclude_paths = /^$/
+      self.include_names = /.*/
+      self.exclude_names = /^$/
+      self.exclude_engines = /^$/
+      self.camelize = nil
+      self.output_dir = Rails.root.join('app', 'assets', 'javascripts')
+    end
+
+    # @param env [Hash{String=>String}]
+    def configure_with_env_vars(env = ENV)
+      %w[include_paths exclude_paths include_names exclude_names exclude_engines].each do |name|
+        public_send("#{name}=", Regexp.new(env[name])) if env[name]
+      end
+      self.output_dir = env['output_dir'] if env['output_dir']
+      self.camelize = env['camelize'].presence.to_sym if env['camelize']
+    end
+  end
+end

data/lib/js_rails_routes/generator.rb

@@ -1,108 +1,40 @@
 # frozen_string_literal: true
 
-require 'singleton'
+require 'js_rails_routes/route_set'
+require 'js_rails_routes/builder'
 
 module JSRailsRoutes
   class Generator
-    COMPARE_REGEXP = %r{:(.*?)(/|$)}
-
-    PROCESS_FUNC = <<-JAVASCRIPT.strip_heredoc.freeze
-      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
-
-    include Singleton
-
-    attr_accessor :include_paths,
-                  :exclude_paths,
-                  :include_names,
-                  :exclude_names,
-                  :exclude_engines,
-                  :output_dir,
-                  :camelize
-
-    def initialize
-      self.include_paths   = /.*/
-      self.exclude_paths   = /^$/
-      self.include_names   = /.*/
-      self.exclude_names   = /^$/
-      self.exclude_engines = /^$/
-      self.camelize = nil
-
-      self.output_dir = Rails.root.join('app', 'assets', 'javascripts')
-      Rails.application.reload_routes!
+    # @param builder [JSRailsRoutes::Builder]
+    # @param writable [#write]
+    def initialize(builder, writable: File)
+      @builder = builder
+      @writable = writable
     end
 
+    # @param task [String]
+    # @return [Hash{String => String}]
     def generate(task)
-      routes_with_engines.each do |rails_engine_name, routes|
-        lines = ["// Don't edit manually. `rake #{task}` generates this file.", PROCESS_FUNC]
-        lines += routes.map do |route_name, route_path|
-          handle_route(route_name, route_path) if match?(route_name, route_path)
-        end.compact
-
-        lines += [''] # End with new line
-        write(rails_engine_name, lines.join("\n"))
+      builder.build.each do |name, body|
+        file_name = File.join(config.output_dir, "#{convert(name)}-routes.js")
+        file_body = "// Don't edit manually. `rake #{task}` generates this file.\n#{body}"
+        writable.write(file_name, file_body)
       end
     end
 
     private
 
-    def match?(route_name, route_path)
-      return false if include_paths !~ route_path
-      return false if exclude_paths =~ route_path
-      return false if include_names !~ route_name
-      return false if exclude_names =~ route_name
-      true
-    end
-
-    def handle_route(route_name, route_path)
-      keys = []
-      while route_path =~ COMPARE_REGEXP
-        keys.push("'#{Regexp.last_match(1)}'")
-        route_path.sub!(COMPARE_REGEXP, "' + params.#{Regexp.last_match(1)} + '#{Regexp.last_match(2)}")
-      end
-
-      function_name = make_function_name(route_name)
-      "export function #{function_name}(params) { return process('#{route_path}', params, [#{keys.join(',')}]); }"
-    end
-
-    def routes_with_engines
-      @routes_with_engines ||= [default_routes] + subengine_routes
-    end
-
-    def make_function_name(route_name)
-      url_helper_name = route_name + '_path'
-      camelize.nil? ? url_helper_name : url_helper_name.camelize(camelize)
-    end
-
-    def make_routes(routes)
-      routes
-        .select(&:name)
-        .map { |r| [r.name, r.path.spec.to_s.split('(')[0]] }
-        .sort_by(&:first)
-    end
-
-    def write(rails_engine_name, string)
-      file_name = File.join(output_dir, "#{rails_engine_name.gsub('::Engine', '').downcase}-routes.js")
-      File.write(file_name, string)
-    end
+    attr_reader :writable, :builder
 
-    def subengine_routes
-      Rails::Engine.subclasses
-                   .reject { |klass| klass.to_s.downcase =~ exclude_engines }
-                   .map { |engine| [engine.to_s, make_routes(engine.routes.routes)] }
-                   .reject { |_, routes| routes.empty? }
+    # @return [JSRailsRoutes::Configuration]
+    def config
+      JSRailsRoutes.config
     end
 
-    def default_routes
-      ['Rails', make_routes(Rails.application.routes.routes)]
+    # @param engine_name [String]
+    # @return [String]
+    def convert(engine_name)
+      engine_name.gsub('::Engine', '').underscore.tr('/', '-')
     end
   end
 end

data/lib/js_rails_routes/language/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module JSRailsRoutes
+  module Language
+    class Base
+      # @param routes [JSRailsRoutes::RouteSet]
+      # @return [String]
+      def handle_route_set(routes) # rubocop:disable Lint/UnusedMethodArgument
+        raise NotImplementedError
+      end
+
+      private
+
+      # @return [JSRailsRoutes::Configuration]
+      def config
+        JSRailsRoutes.config
+      end
+    end
+  end
+end

data/lib/js_rails_routes/language/javascript.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'js_rails_routes/route'
+require 'js_rails_routes/language/base'
+
+module JSRailsRoutes
+  module Language
+    class JavaScript < Base
+      PROCESS_FUNC = <<~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
+
+      # @note Implementation for {JSRailsRoutes::Language::Base#generate}
+      def handle_route_set(routes)
+        routes.each_with_object([PROCESS_FUNC]) do |route, lines|
+          lines.push(handle_route(route))
+        end.join("\n") + "\n"
+      end
+
+      # @param route [JSRailsRoutes::Route]
+      # @return [String]
+      def handle_route(route)
+        path, keys = parse(route.path)
+        name = function_name(route.name)
+        "export function #{name}(params) { return process('#{path}', params, [#{keys.join(',')}]); }"
+      end
+
+      private
+
+      # @param route_path [String]
+      # @return [Array<(String, Array<String>)>]
+      def parse(route_path)
+        destructured_path = route_path.dup
+        keys = []
+        while destructured_path =~ JSRailsRoutes::PARAM_REGEXP
+          keys.push("'#{Regexp.last_match(1)}'")
+          destructured_path.sub!(
+            JSRailsRoutes::PARAM_REGEXP,
+            "' + params.#{Regexp.last_match(1)} + '#{Regexp.last_match(2)}"
+          )
+        end
+        [destructured_path, keys]
+      end
+
+      # @param route_name [String]
+      # @return [String]
+      def function_name(route_name)
+        url_helper_name = route_name + '_path'
+        config.camelize.nil? ? url_helper_name : url_helper_name.camelize(config.camelize)
+      end
+    end
+  end
+end

data/lib/js_rails_routes/route.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSRailsRoutes
+  # Encapsulate a single routing rule
+  class Route
+    # @return [String]
+    attr_reader :name
+
+    # @return [String]
+    attr_reader :path
+
+    # @param route [ActionDispatch::Journey::Route]
+    def initialize(route)
+      @name = route.name
+      @path = route.path.spec.to_s.split('(').first
+    end
+
+    # @return [Boolean]
+    def match? # rubocop:disable Metrics/AbcSize
+      return false if config.include_paths !~ path
+      return false if config.exclude_paths =~ path
+      return false if config.include_names !~ name
+      return false if config.exclude_names =~ name
+      true
+    end
+
+    private
+
+    # @return [JSRailsRoutes::Configuration]
+    def config
+      JSRailsRoutes.config
+    end
+  end
+end

data/lib/js_rails_routes/route_set.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'js_rails_routes/route'
+
+module JSRailsRoutes
+  # Encapsulate a set of routes
+  class RouteSet
+    include ::Enumerable
+
+    # @return [Array<JSRailsRoutes::RouteSet>]
+    def self.correct_matching_route_set_list
+      [
+        RouteSet.new('Rails', ::Rails.application.routes),
+        ::Rails::Engine.subclasses.map do |engine|
+          RouteSet.new(engine.name, engine.routes)
+        end
+      ].flatten.select(&:match?)
+    end
+
+    # @!method each
+    #  @yield [JSRailsRoutes::Route>]
+    #  @note Implementation for {Enumerable}
+    delegate :each, to: :routes
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [Array<JSRailsRoutes::Route>]
+    attr_reader :routes
+
+    # @param name [String] engine name
+    # @param routes [ActionDispatch::Routing::RouteSet]
+    def initialize(name, routes)
+      @name = name
+      @routes = routes.routes
+                      .select(&:name)
+                      .map { |route| Route.new(route) }
+                      .select(&:match?)
+    end
+
+    # @return [Boolean]
+    def match?
+      name !~ config.exclude_engines && routes.present?
+    end
+
+    private
+
+    # @return [JSRailsRoutes::Configuration]
+    def config
+      JSRailsRoutes.config
+    end
+  end
+end

data/lib/js_rails_routes/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSRailsRoutes
-  VERSION = '0.7.0'
+  VERSION = '0.7.1'
 end

data/lib/js_rails_routes.rb

@@ -1,13 +1,47 @@
 # frozen_string_literal: true
 
 require 'js_rails_routes/engine'
+require 'js_rails_routes/configuration'
 require 'js_rails_routes/generator'
 require 'js_rails_routes/version'
+require 'js_rails_routes/language/javascript'
 
 module JSRailsRoutes
+  PARAM_REGEXP = %r{:(.*?)(/|$)}
+
   module_function
 
+  # @yield [Configuration]
   def configure
-    yield Generator.instance if block_given?
+    yield config if block_given?
+  end
+
+  # Current configuration.
+  #
+  # @return [Configuration]
+  def config
+    @config ||= Configuration.new
+  end
+
+  # @param task [String]
+  def generate_javascript(task)
+    builder = Builder.new(Language::JavaScript.new)
+    Generator.new(builder).generate(task)
+  end
+
+  # Execute a given block within a new sandbox. For test purpose.
+  #
+  # @yield
+  def sandbox
+    raise 'Already in a sandbox' if @sandbox
+    @sandbox = true
+    prev = @config
+    @config = Configuration.new
+    begin
+      yield if block_given?
+    ensure
+      @config = prev
+      @sandbox = nil
+    end
   end
 end

data/lib/tasks/js_rails_routes.rake

@@ -3,14 +3,8 @@
 desc 'Generate a ES6 module that contains Rails routes'
 namespace :js do
   task routes: :environment do |task|
-    generator = JSRailsRoutes::Generator.instance
-    generator.include_paths = Regexp.new(ENV['include_paths']) if ENV['include_paths']
-    generator.exclude_paths = Regexp.new(ENV['exclude_paths']) if ENV['exclude_paths']
-    generator.include_names = Regexp.new(ENV['include_names']) if ENV['include_names']
-    generator.exclude_names = Regexp.new(ENV['exclude_names']) if ENV['exclude_names']
-    generator.output_dir = ENV['output_dir'] if ENV['output_dir']
-    generator.camelize = ENV['camelize']&.to_sym if ENV['camelize']
-    generator.generate(task)
-    puts "Routes saved into #{generator.output_dir}."
+    JSRailsRoutes.config.configure_with_env_vars
+    JSRailsRoutes.generate_javascript(task)
+    puts "Routes saved into #{JSRailsRoutes.config.output_dir}."
   end
 end

data/spec/js_rails_routes/builder_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+RSpec.describe JSRailsRoutes::Builder do
+  subject(:builder) { described_class.new(language, route_set_list) }
+
+  include_context 'run in a sandbox'
+
+  let(:language) { instance_double('JSRailsRoutes::Language::Base', handle_route_set: body) }
+  let(:body) { 'hello' }
+  let(:route_set_list) { [rails_route_set, engine_route_set] }
+
+  let(:rails_route_set) do
+    route_set = ActionDispatch::Routing::RouteSet.new.tap do |routes|
+      routes.draw do
+        get '/articles' => 'articles#index'
+      end
+    end
+    JSRailsRoutes::RouteSet.new('Rails', route_set)
+  end
+
+  let(:engine_route_set) do
+    route_set = ActionDispatch::Routing::RouteSet.new.tap do |routes|
+      routes.draw do
+        get '/users' => 'users#index'
+      end
+    end
+    JSRailsRoutes::RouteSet.new('Users::Engine', route_set)
+  end
+
+  describe '#build' do
+    subject { builder.build }
+
+    it 'returns a hash between engine name and its content' do
+      is_expected.to match(rails_route_set.name => body, engine_route_set.name => body)
+      expect(language).to have_received(:handle_route_set).twice
+    end
+  end
+end

data/spec/js_rails_routes/configuration_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+RSpec.describe JSRailsRoutes::Configuration do
+  subject(:config) { described_class.new }
+
+  describe '#configure_with_env_vars' do
+    subject { config.configure_with_env_vars(env) }
+
+    context 'with empty env' do
+      let(:env) { Hash[] }
+
+      it 'does not change' do
+        expect { subject }.to not_change(config, :include_paths)
+                         .and not_change(config, :exclude_paths)
+                         .and not_change(config, :include_names)
+                         .and not_change(config, :exclude_names)
+                         .and not_change(config, :exclude_engines)
+                         .and not_change(config, :output_dir)
+                         .and not_change(config, :camelize)
+      end
+    end
+
+    context 'with include_paths env' do
+      let(:env) { Hash['include_paths' => 'a'] }
+
+      it 'changes #include_paths' do
+        expect { subject }.to change(config, :include_paths).to eq(/a/)
+      end
+    end
+
+    context 'with exclude_paths env' do
+      let(:env) { Hash['exclude_paths' => 'a'] }
+
+      it 'changes #exclude_paths' do
+        expect { subject }.to change(config, :exclude_paths).to eq(/a/)
+      end
+    end
+
+    context 'with include_names env' do
+      let(:env) { Hash['include_names' => 'a'] }
+
+      it 'changes #include_names' do
+        expect { subject }.to change(config, :include_names).to eq(/a/)
+      end
+    end
+
+    context 'with exclude_names env' do
+      let(:env) { Hash['exclude_names' => 'a'] }
+
+      it 'changes #exclude_names' do
+        expect { subject }.to change(config, :exclude_names).to eq(/a/)
+      end
+    end
+
+    context 'with exclude_engines env' do
+      let(:env) { Hash['exclude_engines' => 'a'] }
+
+      it 'changes #exclude_engines' do
+        expect { subject }.to change(config, :exclude_engines).to eq(/a/)
+      end
+    end
+
+    context 'with output_dir env' do
+      let(:env) { Hash['output_dir' => 'path'] }
+
+      it 'changes #output_dir' do
+        expect { subject }.to change(config, :output_dir).to eq 'path'
+      end
+    end
+
+    context 'with camelize env' do
+      let(:env) { Hash['camelize' => 'lower'] }
+
+      it 'changes #camelize' do
+        expect { subject }.to change(config, :camelize).to eq :lower
+      end
+    end
+  end
+end