privatenote_olive_branch 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8b71202e524bfcc0c98fdc1a178ccdfa90c404127a63a2502b2557038f6d0c30
+  data.tar.gz: 13fb35ee7e97a80a635d759d4ea86b38d102292c27239c83507aaef8a24271b2
+SHA512:
+  metadata.gz: ee5c41e04b759bef485b4f97ec53004861e7456696d0ae4bc8861378fdc7d739547384e485f6afdc84157c0048462c8462b3cd6202dcac15acaf4bcbfbba58f7
+  data.tar.gz: 2e42b65c14b7c2dc13b490a748351cdfff83e3eb625838f627b52ef029635d757ed7d52e1260f58f3aeb956a0be3c1e7dcb0ff6a789d27f5f89f75bdf32ed4dc

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Eli Fatsi (Viget)
+
+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,153 @@
+# OliveBranch
+
+[![Code Climate](https://codeclimate.com/github/vigetlabs/olive_branch.png)](https://codeclimate.com/github/vigetlabs/olive_branch)
+[![Build Status](https://travis-ci.org/vigetlabs/olive_branch.svg?branch=master)](https://travis-ci.org/vigetlabs/olive_branch)
+
+This gem lets your API users pass in and receive camelCased or dash-cased keys, while your Rails app receives and produces snake_cased ones.
+
+## 📣 This repository is forked repo.
+
+The original repository is no longer actively maintained. (last updated on Nov 19, 2021)
+
+To prepare for problems that may arise, we decided to fork and use it.
+
+This forked repository is also under the MIT License same as original repository.
+
+## Install
+
+1. Add this to your Gemfile and then `bundle install`:
+
+```ruby
+gem "olive_branch"
+```
+
+2. Add this to `config/applcation.rb` if you want the clients to control the transformation behaviour through the `Key-Inflection` HTTP header sent by the client:
+
+```ruby
+config.middleware.use OliveBranch::Middleware
+```
+
+Alternative, if you want to always convert between snake_case and camelCase for your API and only your API, to keep Rubyist and JavaScript developer's happy, use the following configuration:
+
+```ruby
+excluded_routes = ->(env) { !env["PATH_INFO"].match(%r{^/api}) }
+config.middleware.use OliveBranch::Middleware,
+                      inflection:       "camel",
+                      exclude_params:   excluded_routes,
+                      exclude_response: excluded_routes
+```
+
+in your `config/application.rb`.
+
+## Use
+
+Include a `Key-Inflection` header with values of `camel`, `dash`, `snake` or `pascal` in your JSON API requests.
+
+For more examples, see [our blog post](https://www.viget.com/articles/introducing-olivebranch).
+
+## Optimizations and configuration
+
+`OliveBranch` uses `multi_json`, which will automatically choose the fastest available JSON parsing library present in your application.
+Most Ruby applications default to using the JSON library that ships with Ruby. However, by including a coder that `multi_json` considers faster, like [Oj](https://github.com/ohler55/oj) in your gemfile, you can potentially save up to ~20% response time.
+
+The middleware can be initialized with custom camelize/dasherize implementations, so if you know you have a fixed size set of keys, you can save a considerable amount of time by providing a custom camelize that caches like so:
+
+```ruby
+class FastCamel
+  def self.camel_cache
+    @camel_cache ||= {}
+  end
+
+  def self.camelize(string)
+    camel_cache[string] ||= string.underscore.camelize(:lower)
+  end
+end
+
+
+...
+
+config.middleware.use OliveBranch::Middleware, camelize: FastCamel.method(:camelize)
+```
+
+Default inflection header key can be changed like
+
+```ruby
+config.middleware.use OliveBranch::Middleware, inflection_header: 'Inflect-With'
+```
+
+A default inflection can be specified so you don't have to include the `Key-Inflection` header on every request. If you opt for default inflection, you may want to exclude the routes that Rails uses (see Filtering).
+
+```ruby
+config.middleware.use OliveBranch::Middleware, inflection: 'camel'
+```
+
+A benchmark of this compared to the standard implementation shows a saving of ~75% rails response times for a complex response payload, or a ~400% improvement, but there is a risk of memory usage ballooning if you have dynamic keys. You can make this method as complex as required, but keep in mind that it will end up being called a _lot_ in a busy app, so it's worth thinking about how to do what you need in the fastest manner possible.
+
+### Filtering
+
+#### Content type
+
+It is also possible to include a custom content type check in the same manner
+
+```ruby
+config.middleware.use OliveBranch::Middleware, content_type_check: -> (content_type) {
+  content_type == "my/content-type"
+}
+```
+
+#### Excluding URLs
+
+Additionally you can define a custom check by passing a proc
+
+For params transforming
+
+```ruby
+config.middleware.use OliveBranch::Middleware, exclude_params: -> (env) {
+  env['PATH_INFO'].match(/^\/do_not_transform/)
+}
+```
+
+Or response transforming
+
+```ruby
+config.middleware.use OliveBranch::Middleware, exclude_response: -> (env) {
+  env['PATH_INFO'].match(/^\/do_not_transform/)
+}
+```
+
+#### Rails routes & Action Text
+
+If you're using default inflection, exclude the routes that Rails uses
+
+```ruby
+rails_routes = -> (env) { env['PATH_INFO'].match(/^\/rails/) }
+config.middleware.use OliveBranch::Middleware, inflection: "camel", exclude_params: rails_routes, exclude_response: rails_routes
+```
+
+## Upgrading to version 3
+
+Default inflection header changed from `X-Key-Inflection` to `Key-Inflection`.
+
+## Troubleshooting
+
+We've seen folks raise issues that inbound transformations are not taking place. This is often due to the fact that OliveBranch, by default, is only transforming keys when a request's Content-Type is `application/json`.
+
+Note that your HTTP client library may suppress even a manually specified `Content-Type` header if the request body is empty (e.g. [Axios does this](https://github.com/axios/axios/issues/86)). This is a common gotcha for GET requests, the body of which are [often expected to be empty](https://stackoverflow.com/questions/978061/http-get-with-request-body) for reasons of caching. If you're seeing the middleware perform on POST or PATCH requests, but not GET requests, this may be your issue.
+
+You may choose to force inbound transformation on every request by overriding the `content_type_check` functionality:
+
+```ruby
+config.middleware.use OliveBranch::Middleware, content_type_check: -> (content_type) { true }
+```
+
+---
+
+OliveBranch is released under the [MIT License](http://www.opensource.org/licenses/MIT). See MIT-LICENSE for further details.
+
+---
+
+<a href="http://code.viget.com">
+  <img src="http://code.viget.com/github-banner.png" alt="Code At Viget">
+</a>
+
+Visit [code.viget.com](http://code.viget.com) to see more projects from [Viget.](https://viget.com)

data/lib/olive_branch/middleware.rb

@@ -0,0 +1,128 @@
+require "multi_json"
+
+module OliveBranch
+  class Checks
+    def self.content_type_check(content_type)
+      content_type =~ /application\/json/ || content_type =~ /application\/vnd\.api\+json/
+    end
+
+    def self.default_exclude(env)
+      false
+    end
+  end
+
+  class Transformations
+    class << self
+      def transform(value, transform_method)
+        case value
+        when Array then value.map { |item| transform(item, transform_method) }
+        when Hash then value.deep_transform_keys! { |key| transform(key, transform_method) }
+        when String then transform_method.call(value)
+        else value
+        end
+      end
+
+      def pascalize(string)
+        string.underscore.camelize(:upper)
+      end
+
+      def camelize(string)
+        string.underscore.camelize(:lower)
+      end
+
+      def dasherize(string)
+        string.dasherize
+      end
+
+      def underscore_params(env)
+        req = ActionDispatch::Request.new(env)
+        req.request_parameters
+        req.query_parameters
+
+        env["action_dispatch.request.request_parameters"].deep_transform_keys!(&:underscore)
+        env["action_dispatch.request.query_parameters"].deep_transform_keys!(&:underscore)
+      end
+    end
+  end
+
+  class Middleware
+    def initialize(app, args = {})
+      @app = app
+      @camelize = args[:camelize] || Transformations.method(:camelize)
+      @dasherize = args[:dasherize] || Transformations.method(:dasherize)
+      @pascalize = args[:pascalize] || Transformations.method(:pascalize)
+      @content_type_check = args[:content_type_check] || Checks.method(:content_type_check)
+      @exclude_response = args[:exclude_response] || Checks.method(:default_exclude)
+      @exclude_params = args[:exclude_params] || Checks.method(:default_exclude)
+      @default_inflection = args[:inflection]
+      @inflection_header = args.fetch(:inflection_header, 'Key-Inflection').gsub(/[^a-z0-9]/i, '_').upcase
+      @inflection_header = "HTTP_#{@inflection_header}" unless @inflection_header.start_with?('HTTP_')
+    end
+
+    def call(env)
+      Transformations.underscore_params(env) unless exclude_params?(env)
+      status, headers, response = @app.call(env)
+
+      return [status, headers, response] if exclude_response?(env, headers)
+
+      new_responses = []
+
+      response.each do |body|
+        begin
+          new_response = MultiJson.load(body)
+        rescue MultiJson::ParseError
+          new_responses << body
+          next
+        end
+
+        Transformations.transform(new_response, inflection_method(env))
+
+        new_responses << MultiJson.dump(new_response)
+      end
+
+      [status, headers, new_responses]
+    end
+
+    private
+
+    def exclude_params?(env)
+      exclude?(env, env["CONTENT_TYPE"], @exclude_params)
+    end
+
+    def exclude_response?(env, headers)
+      exclude_rails_route?(env) ||
+        exclude?(env, headers['Content-Type'], @exclude_response)
+    end
+
+    def exclude?(env, content_type, block)
+      !inflection_type(env) || !valid_content_type?(content_type) || block.call(env)
+    end
+
+    def exclude_rails_route?(env)
+      env['PATH_INFO'].to_s.start_with?('/rails')
+    end
+
+    def valid_content_type?(content_type)
+      @content_type_check.call(content_type)
+    end
+
+    def inflection_type(env)
+      env[@inflection_header] || @default_inflection
+    end
+
+    def inflection_method(env)
+      inflection = inflection_type(env)
+
+      if inflection == "camel"
+        @camelize
+      elsif inflection == "dash"
+        @dasherize
+      elsif inflection == 'pascal'
+        @pascalize
+      else
+        # probably misconfigured, do nothing
+        -> (string) { string }
+      end
+    end
+  end
+end

data/lib/olive_branch/version.rb

@@ -0,0 +1,3 @@
+module OliveBranch
+  VERSION = '1.0.0'
+end

data/lib/olive_branch.rb

@@ -0,0 +1,3 @@
+module OliveBranch
+  autoload :Middleware, "olive_branch/middleware"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: privatenote_olive_branch
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Privatenote
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Handle camel/snake/dash case conversion. forked from vigetlabs/olive_branch.
+email:
+- dev@privatenote.co.kr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/olive_branch.rb
+- lib/olive_branch/middleware.rb
+- lib/olive_branch/version.rb
+homepage: https://github.com/privatenote/olive_branch
+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.3.7
+signing_key:
+specification_version: 4
+summary: Handle camel/snake/dash case conversion
+test_files: []