active_params 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47ecec5d8833f17831a4d8ca416714fc356cd4b8
-  data.tar.gz: 8b0641f760e01cf63a9c7d2c35e16f1039451276
+  metadata.gz: 89e4ec3b12048b26afb3516aad053d9bd624b77c
+  data.tar.gz: b036a0b06d54324fc28335d3ad106a4772af290d
 SHA512:
-  metadata.gz: 92a4f7043edb9dae18ac1d9ab9d6f94a902c7e6339364318ee2d0792c9afbeb4744cbfc1f35967d19e8416c25bc81733d125a50444a827010524a3aeb1296940
-  data.tar.gz: 5de694ee1858bac35b7c2548748d2946cd7f3989d2c0589f914fb3e7b4c1727d3930696f2a3aba4a1752e332e2d20cfa74e5350756f0a17c0dcece141e94e5f3
+  metadata.gz: 2dfc110db66b78be2d862e8e41f4e621e680d7028c78256087349f413fc2bf0a5bc9a99e22986ea600fcac47fe5db5c3964caaede6e687f380ebeba7f52cae53
+  data.tar.gz: d821671fb2ea4db41c0cd0fd10473e635739e0f1c81b05d0b2fc062291f740b5cdea9597b1b25d815ad0f4661ba59d662677b548aad9e8e408bb1117e2cc47ba

data/README.md

@@ -91,6 +91,41 @@ end
 
 When you create new features for your app & try them out in development mode, `config/active_params.json` will be automatically updated. When you commit your code, include the changes to `config/active_params.json` too.
 
+### Static Customizations
+
+You can add a `config/initializers/active_params.rb` file in your Rails app, and perform a global config like this
+
+```ruby
+ActiveParams.config do |config|
+  config.writing = Rails.env.development?
+  config.path    = "config/active_params.json"
+  config.scope   = proc { |controller|
+    "#{controller.request.method} #{controller.controller_name}/#{controller.action_name}"
+  }
+end
+```
+
+### Dynamic Customizations
+
+Each controller may need its own config, e.g. some strong params are only permitted for certain current_user roles. For such controllers, use the `include ActiveParams.setup(...)` syntax instead
+
+```ruby
+class ApplicationController < ActionController::Base
+  include ActiveParams.setup({
+    path: "tmp/strong_params.json",
+    writing: !Rails.env.production?,
+    scope: proc {|ctrl|
+      [ctrl.current_user.role, ActiveParams.scope.(ctrl)].join('@')
+    },
+  })
+end
+```
+
+You can setup
+- where the config file is stored
+- if you want to write to the config file
+- how should strong params be scoped
+
 ## LICENSE
 
 MIT

data/lib/active_params.rb

@@ -1,86 +1,38 @@
 require "active_params/version"
+require "active_params/parser"
+require "active_params/controller"
 
 module ActiveParams
-  def write_strong_params(global_config: ActiveParams.global_config)
-    current_config = global_config["#{request.method} #{controller_name}/#{action_name}"] ||= {}
-    params.each do |k,v|
-      case result = ActiveParams.strong_params_definition_for(v)
-      when Array, Hash
-        current_config[k] = result
-      end
-    end
-    open(ActiveParams.path, "wb") {|f| f.write(JSON.pretty_generate(global_config)) }
-    yield
-  end
+  class << self
+    attr_accessor :writing, :path, :scope
 
-  def apply_strong_params(global_config: ActiveParams.global_config)
-    # e.g. POST users#update
-    current_config = global_config["#{request.method} #{controller_name}/#{action_name}"] ||= {}
-    params.each do |k,v|
-      if result = current_config[k]
-        params[k] = params.require(k).permit(result)
-      end
+    # ActiveParams.config {|c| .... }
+    def config
+      yield self
     end
-    yield
-  end
 
-  def self.included(base)
-    if base.methods.include? :around_action
-      base.class_eval do
-        around_action :write_strong_params if ActiveParams.development_mode?
-        around_action :apply_strong_params
-      end
+    # `include ActiveParams` use default settings
+    def included(base)
+      base.send(:include, setup)
     end
-  end
 
-  def self.development_mode?
-    defined?(Rails) && Rails.env.development?
-  end
-
-  def self.path
-    ENV.fetch("ACTIVE_PARAMS_PATH", "config/active_params.json")
-  end
-
-  def self.global_config
-    @@global_config ||= (File.exists?(ActiveParams.path) ? JSON.parse(IO.read ActiveParams.path) : {})
-  ensure
-    # undo cache in development mode
-    @@global_config = nil if development_mode?
-  end
-
-  # to obtain a hash of all possible keys
-  def self.combine_hashes(array_of_hashes)
-    array_of_hashes.select {|v| v.kind_of?(Hash) }.
-      inject({}) {|sum, hash| hash.inject(sum) {|sum,(k,v)| sum.merge(k => v) } }
-  end
-
-  def self.strong_params_definition_for(params)
-    if params.kind_of?(Array)
-      combined_hash = combine_hashes(params)
-      if combined_hash.empty?
-        []
-      else
-        strong_params_definition_for(combined_hash)
-      end
-    elsif params.respond_to?(:keys) # Hash, ActionController::Parameters
-      values, arrays = [[], {}]
-      params.each do |key, value|
-        case value
-        when Array
-          arrays[key] = strong_params_definition_for(value)
-        when Hash
-          arrays[key] = strong_params_definition_for(combine_hashes(value.values))
-        else
-          values.push(key)
+    # `include ActiveParams.setup({...})` customize
+    def setup(options = {})
+      Module.new do
+        def self.included(base)
+          base.send(:include, ActiveParams::Controller)
         end
+      end.tap do |m|
+        m.send(:define_method, :active_params_options) { options }
       end
-      if arrays.empty?
-        values
-      else
-        [*values.sort, arrays]
-      end
-    else
-      params
     end
   end
 end
+
+ActiveParams.config do |config|
+  config.writing = defined?(Rails) && Rails.env.development?
+  config.path    = "config/active_params.json"
+  config.scope   = proc { |controller|
+    "#{controller.request.method} #{controller.controller_name}/#{controller.action_name}"
+  }
+end

data/lib/active_params/controller.rb

@@ -0,0 +1,61 @@
+require "json"
+
+module ActiveParams
+  module Controller
+    def self.included(base)
+      add_before_method =
+        (base.methods.include?(:before_action) && :before_action) ||
+        (base.methods.include?(:before_filter) && :before_filter)
+
+      if add_before_method
+        base.class_eval do
+          send add_before_method, :active_params_write, if: :active_params_writing?
+          send add_before_method, :active_params_apply
+        end
+      end
+    end
+
+    def active_params_writing?
+      active_params_options[:writing] || ActiveParams.writing
+    end
+
+    def active_params_path
+      active_params_options[:path] || ActiveParams.path
+    end
+
+    def active_params_json
+      @@active_params_json ||= (File.exists?(active_params_path) ? JSON.parse(IO.read active_params_path) : {})
+    rescue JSON::ParserError
+      return {}
+    ensure
+      # undo cache in development mode
+      @@active_params_json = nil if active_params_writing?
+    end
+
+    def active_params_scope
+      scope = active_params_options[:scope] || ActiveParams.scope
+      scope.respond_to?(:call) ? scope.(self) : scope
+    end
+
+    def active_params_write(global_json: active_params_json)
+      scoped_json = global_json[active_params_scope] ||= {}
+      params.each do |k,v|
+        case result = ActiveParams::Parser.strong_params_definition_for(v)
+        when Array, Hash
+          scoped_json[k] = result
+        end
+      end
+      open(active_params_path, "wb") {|f| f.write(JSON.pretty_generate(global_json)) }
+    end
+
+    def active_params_apply(global_json: active_params_json)
+      # e.g. POST users#update
+      scoped_json = global_json[active_params_scope] ||= {}
+      params.each do |k,v|
+        if result = scoped_json[k]
+          params[k] = params.require(k).permit(result)
+        end
+      end
+    end
+  end
+end

data/lib/active_params/parser.rb

@@ -0,0 +1,41 @@
+module ActiveParams
+  module Parser
+    # to obtain a hash of all possible keys
+    def combine_hashes(array_of_hashes)
+      array_of_hashes.select {|v| v.kind_of?(Hash) }.
+        inject({}) {|sum, hash| hash.inject(sum) {|sum,(k,v)| sum.merge(k => v) } }
+    end
+
+    def strong_params_definition_for(params)
+      if params.kind_of?(Array)
+        combined_hash = combine_hashes(params)
+        if combined_hash.empty?
+          []
+        else
+          strong_params_definition_for(combined_hash)
+        end
+      elsif params.respond_to?(:keys) # Hash, ActionController::Parameters
+        values, arrays = [[], {}]
+        params.each do |key, value|
+          case value
+          when Array
+            arrays[key] = strong_params_definition_for(value)
+          when Hash
+            arrays[key] = strong_params_definition_for(combine_hashes(value.values))
+          else
+            values.push(key)
+          end
+        end
+        if arrays.empty?
+          values
+        else
+          [*values.sort, arrays]
+        end
+      else
+        params
+      end
+    end
+
+    self.extend(self)
+  end
+end

data/lib/active_params/version.rb

@@ -1,3 +1,3 @@
 module ActiveParams
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_params
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - choonkeat
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-27 00:00:00.000000000 Z
+date: 2016-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -69,6 +69,8 @@ files:
 - bin/console
 - bin/setup
 - lib/active_params.rb
+- lib/active_params/controller.rb
+- lib/active_params/parser.rb
 - lib/active_params/version.rb
 homepage: http://github.com/choonkeat/active_params
 licenses: []
@@ -89,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
 summary: Automatic strong parameters