requestjs-rails 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9916bd029b2135b5211b19d728b8f046ac451c69796b25aaf97e5cf003a90ca
+  data.tar.gz: 6ff947cb98c9692d7da177fcb99a3c2b5cc9804c7cb34b78265a1bd532077345
+SHA512:
+  metadata.gz: 986c4734b1ce9a324dace368d029a4bb5dea55dfe9a00265cdb0ffd29aa0a53b235cf4d0b37a3110bee1795b4116aa3667cb5ffe47354bc46ee25f44496e1983
+  data.tar.gz: 96238d856e7b6ae9c1c27495a1ab842ca51115642dedef49895e9d87fa46376c0892daa05f79b412f202332774b7ead4bdae2a729505d618eef75e18ac7b38da

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2021 Marcelo Lauxen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,27 @@
+# Request.JS for Rails
+
+[Rails Request.JS](https://github.com/rails/request.js) encapsulates the logic to send by default some headers that are required by rails applications like the `X-CSRF-Token`.
+
+## Installation
+
+1. Add the `requestjs-rails` gem to your Gemfile: `gem 'requestjs-rails'`
+2. Run `./bin/bundle install`.
+3. Run `./bin/rails requestjs:install`
+
+If using the asset pipeline to manage JavaScript, the last command will:
+
+- Append import "@rails/request.js" to your app/assets/javascripts/application.js entrypoint.
+
+Make sure you've already installed `importmap-rails` and that it's referenced before `requestjs-rails` in your Gemfile.
+
+If using Webpacker to manage JavaScript, the last command will:
+
+- Install the Request.JS NPM package.
+
+## Usage
+
+With the installation done check the documentation in the [Rails Request.JS](https://github.com/rails/request.js#how-to-use) repository.
+
+## License
+
+Request.JS for Rails is released under the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/javascripts/rails-requestjs.js

@@ -0,0 +1 @@
+//= require ./requestjs.js

data/app/assets/javascripts/requestjs.js

@@ -0,0 +1,257 @@
+class FetchResponse {
+  constructor(response) {
+    this.response = response;
+  }
+  get statusCode() {
+    return this.response.status;
+  }
+  get redirected() {
+    return this.response.redirected;
+  }
+  get ok() {
+    return this.response.ok;
+  }
+  get unauthenticated() {
+    return this.statusCode === 401;
+  }
+  get authenticationURL() {
+    return this.response.headers.get("WWW-Authenticate");
+  }
+  get contentType() {
+    const contentType = this.response.headers.get("Content-Type") || "";
+    return contentType.replace(/;.*$/, "");
+  }
+  get headers() {
+    return this.response.headers;
+  }
+  get html() {
+    if (this.contentType.match(/^(application|text)\/(html|xhtml\+xml)$/)) {
+      return this.text;
+    }
+    return Promise.reject(new Error(`Expected an HTML response but got "${this.contentType}" instead`));
+  }
+  get json() {
+    if (this.contentType.match(/^application\/json/)) {
+      return this.responseJson || (this.responseJson = this.response.json());
+    }
+    return Promise.reject(new Error(`Expected a JSON response but got "${this.contentType}" instead`));
+  }
+  get text() {
+    return this.responseText || (this.responseText = this.response.text());
+  }
+  get isTurboStream() {
+    return this.contentType.match(/^text\/vnd\.turbo-stream\.html/);
+  }
+  async renderTurboStream() {
+    if (this.isTurboStream) {
+      if (window.Turbo) {
+        window.Turbo.renderStreamMessage(await this.text);
+      } else {
+        console.warn("You must set `window.Turbo = Turbo` to automatically process Turbo Stream events with request.js");
+      }
+    } else {
+      return Promise.reject(new Error(`Expected a Turbo Stream response but got "${this.contentType}" instead`));
+    }
+  }
+}
+
+class RequestInterceptor {
+  static register(interceptor) {
+    this.interceptor = interceptor;
+  }
+  static get() {
+    return this.interceptor;
+  }
+  static reset() {
+    this.interceptor = undefined;
+  }
+}
+
+function getCookie(name) {
+  const cookies = document.cookie ? document.cookie.split("; ") : [];
+  const prefix = `${encodeURIComponent(name)}=`;
+  const cookie = cookies.find((cookie => cookie.startsWith(prefix)));
+  if (cookie) {
+    const value = cookie.split("=").slice(1).join("=");
+    if (value) {
+      return decodeURIComponent(value);
+    }
+  }
+}
+
+function compact(object) {
+  const result = {};
+  for (const key in object) {
+    const value = object[key];
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+function metaContent(name) {
+  const element = document.head.querySelector(`meta[name="${name}"]`);
+  return element && element.content;
+}
+
+function stringEntriesFromFormData(formData) {
+  return [ ...formData ].reduce(((entries, [name, value]) => entries.concat(typeof value === "string" ? [ [ name, value ] ] : [])), []);
+}
+
+function mergeEntries(searchParams, entries) {
+  for (const [name, value] of entries) {
+    if (value instanceof window.File) continue;
+    if (searchParams.has(name)) {
+      searchParams.delete(name);
+      searchParams.set(name, value);
+    } else {
+      searchParams.append(name, value);
+    }
+  }
+}
+
+class FetchRequest {
+  constructor(method, url, options = {}) {
+    this.method = method;
+    this.options = options;
+    this.originalUrl = url;
+  }
+  async perform() {
+    try {
+      const requestInterceptor = RequestInterceptor.get();
+      if (requestInterceptor) {
+        await requestInterceptor(this);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+    const response = new FetchResponse(await window.fetch(this.url, this.fetchOptions));
+    if (response.unauthenticated && response.authenticationURL) {
+      return Promise.reject(window.location.href = response.authenticationURL);
+    }
+    if (response.ok && response.isTurboStream) {
+      response.renderTurboStream();
+    }
+    return response;
+  }
+  addHeader(key, value) {
+    const headers = this.additionalHeaders;
+    headers[key] = value;
+    this.options.headers = headers;
+  }
+  get fetchOptions() {
+    return {
+      method: this.method.toUpperCase(),
+      headers: this.headers,
+      body: this.formattedBody,
+      signal: this.signal,
+      credentials: "same-origin",
+      redirect: this.redirect
+    };
+  }
+  get headers() {
+    return compact(Object.assign({
+      "X-Requested-With": "XMLHttpRequest",
+      "X-CSRF-Token": this.csrfToken,
+      "Content-Type": this.contentType,
+      Accept: this.accept
+    }, this.additionalHeaders));
+  }
+  get csrfToken() {
+    return getCookie(metaContent("csrf-param")) || metaContent("csrf-token");
+  }
+  get contentType() {
+    if (this.options.contentType) {
+      return this.options.contentType;
+    } else if (this.body == null || this.body instanceof window.FormData) {
+      return undefined;
+    } else if (this.body instanceof window.File) {
+      return this.body.type;
+    }
+    return "application/json";
+  }
+  get accept() {
+    switch (this.responseKind) {
+     case "html":
+      return "text/html, application/xhtml+xml";
+
+     case "turbo-stream":
+      return "text/vnd.turbo-stream.html, text/html, application/xhtml+xml";
+
+     case "json":
+      return "application/json";
+
+     default:
+      return "*/*";
+    }
+  }
+  get body() {
+    return this.options.body;
+  }
+  get query() {
+    const originalQuery = (this.originalUrl.split("?")[1] || "").split("#")[0];
+    const params = new URLSearchParams(originalQuery);
+    let requestQuery = this.options.query;
+    if (requestQuery instanceof window.FormData) {
+      requestQuery = stringEntriesFromFormData(requestQuery);
+    } else if (requestQuery instanceof window.URLSearchParams) {
+      requestQuery = requestQuery.entries();
+    } else {
+      requestQuery = Object.entries(requestQuery || {});
+    }
+    mergeEntries(params, requestQuery);
+    const query = params.toString();
+    return query.length > 0 ? `?${query}` : "";
+  }
+  get url() {
+    return this.originalUrl.split("?")[0] + this.query;
+  }
+  get responseKind() {
+    return this.options.responseKind || "html";
+  }
+  get signal() {
+    return this.options.signal;
+  }
+  get redirect() {
+    return this.options.redirect || "follow";
+  }
+  get additionalHeaders() {
+    return this.options.headers || {};
+  }
+  get formattedBody() {
+    const bodyIsAString = Object.prototype.toString.call(this.body) === "[object String]";
+    const contentTypeIsJson = this.headers["Content-Type"] === "application/json";
+    if (contentTypeIsJson && !bodyIsAString) {
+      return JSON.stringify(this.body);
+    }
+    return this.body;
+  }
+}
+
+async function get(url, options) {
+  const request = new FetchRequest("get", url, options);
+  return request.perform();
+}
+
+async function post(url, options) {
+  const request = new FetchRequest("post", url, options);
+  return request.perform();
+}
+
+async function put(url, options) {
+  const request = new FetchRequest("put", url, options);
+  return request.perform();
+}
+
+async function patch(url, options) {
+  const request = new FetchRequest("patch", url, options);
+  return request.perform();
+}
+
+async function destroy(url, options) {
+  const request = new FetchRequest("delete", url, options);
+  return request.perform();
+}
+
+export { FetchRequest, FetchResponse, RequestInterceptor, destroy, get, patch, post, put };

data/lib/install/requestjs_with_asset_pipeline.rb

@@ -0,0 +1,4 @@
+APP_JS_ROOT = Rails.root.join("app/assets/javascripts")
+
+say "Import Request.JS in existing app/assets/javascripts/application.js"
+append_to_file APP_JS_ROOT.join("application.js"), %(import "@rails/request.js"\n)

data/lib/install/requestjs_with_webpacker.rb

@@ -0,0 +1,2 @@
+say "Installing Request.JS dependency"
+run "yarn add @rails/request.js"

data/lib/requestjs-rails.rb

@@ -0,0 +1,5 @@
+module Requestjs
+end
+
+require "requestjs/version"
+require "requestjs/engine"

data/lib/requestjs/engine.rb

@@ -0,0 +1,17 @@
+module Requestjs
+  class Engine < ::Rails::Engine
+    initializer "requestjs.assets" do
+      if Rails.application.config.respond_to?(:assets)
+        Rails.application.config.assets.precompile += %w( rails-requestjs )
+      end
+    end
+
+    initializer "requestjs.importmap" do
+      if Rails.application.config.respond_to?(:importmap)
+        Rails.application.config.importmap.paths.tap do |paths|
+          paths.asset "@rails/request.js", path: "rails-requestjs"
+        end
+      end
+    end
+  end
+end

data/lib/requestjs/version.rb

@@ -0,0 +1,3 @@
+module Requestjs
+  VERSION = "0.0.5"
+end

data/lib/tasks/requestjs_tasks.rake

@@ -0,0 +1,28 @@
+def run_requestjs_install_template(path) 
+  system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/#{path}.rb",  __dir__)}"
+end
+
+namespace :requestjs do
+  desc "Install Request.JS into the app"
+  task :install do
+    if defined?(Webpacker::Engine)
+      Rake::Task["requestjs:install:webpacker"].invoke
+    elsif defined?(Importmap)
+      Rake::Task["requestjs:install:asset_pipeline"].invoke
+    else
+      puts "You must either be running Webpacker or importmap-rails to use this gem."
+    end
+  end
+
+  namespace :install do
+    desc "Install Request.JS on the app with the asset pipeline"
+    task :asset_pipeline do
+      run_requestjs_install_template "requestjs_with_asset_pipeline"
+    end
+
+    desc "Install Request.JS on the app with webpacker"
+    task :webpacker do
+      run_requestjs_install_template "requestjs_with_webpacker"
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: requestjs-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Marcelo Lauxen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: 
+email: marcelolauxen16@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/rails-requestjs.js
+- app/assets/javascripts/requestjs.js
+- lib/install/requestjs_with_asset_pipeline.rb
+- lib/install/requestjs_with_webpacker.rb
+- lib/requestjs-rails.rb
+- lib/requestjs/engine.rb
+- lib/requestjs/version.rb
+- lib/tasks/requestjs_tasks.rake
+homepage: https://github.com/marcelolx/requestjs-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.19
+signing_key: 
+specification_version: 4
+summary: A tiny Fetch API wrapper that allows you to make http requests without need
+  to handle to send the CSRF Token on every request
+test_files: []