adequate_exposure 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 331663a8f718896cab6be3800c0af9fc98379e8b
-  data.tar.gz: e942a3866cdd940adf9dd9e08e979b68b8456446
+  metadata.gz: 15f771dd9996bd2a1920e2f00dbc487e568d84ce
+  data.tar.gz: 9db2690bceba1225904077e793d780813f968774
 SHA512:
-  metadata.gz: 4ce222e1500bce49ee95bc6eec47bc7f4956591070fba3b9acf5e5a3e3585296da02c79bb82c6532e65acf7049e39833709e8efe8032a8de58b18a6da26eaf59
-  data.tar.gz: 9e292f24fbf0242ee15b8bb41483a2aa73def2316373612645d94c99592430c31ba41bfc3be9d243326e29f5ee62084ec7e408b3da4b12a5201dd07dcf7645d2
+  metadata.gz: e5cbf18ca89f1b543a5ef99f19059beb805991238219835d827d2090b387bfb5c8c832b10a911f287f88f4bb274ca041e3353b13d91b17e71eb544e6b12c5ee6
+  data.tar.gz: e97dc7d95fe518d7b19a9e93ffd978240eb11de1a1ab6499777c15e6e548c36b581107eaf510e1a959929b4e4f3228da79a3b2402f84c4cef8f577b9afcef477

data/README.md

@@ -17,7 +17,8 @@ that down we can start talking about the API.
 
 ## API
 
-The whole API consists of two methods so far: `expose` and `expose!`.
+The whole API consists of three methods so far: `expose`, `expose!`, and
+`exposure_config`.
 
 In the simplest scenario you'll just use it to expose a model in the
 controller:
@@ -33,7 +34,7 @@ ID and try to perform `Thing.find(id)`. If the ID isn't found, it'll call
 `Thing.new(things_params)`. The result will be memoized in an `@exposed_thing`
 instance variable.
 
-The default resolving workflow if pretty powerful and customizable. It could be
+The default resolving workflow is pretty powerful and customizable. It could be
 expressed with the following pseudocode:
 
 ```ruby
@@ -108,7 +109,7 @@ Or if you (like me) absolutely hate parens in side-effect methods:
 expose :thing, ->{ get_thing_some_way_or_another }
 ```
 
-There is another shortcut that allows you to redefine entire fetch block with
+There is another shortcut that allows you to redefine the entire fetch block with
 less code:
 
 ```ruby
@@ -120,7 +121,7 @@ expose :comments, ->{ post.comments }
 ### `id`
 
 The default fetch logic relies on the presence of an ID. And of course Adequate
-Exposure allows to to specify how exactly you want the ID to be extracted.
+Exposure allows you to specify how exactly you want the ID to be extracted.
 
 Default behavior could be expressed using following code:
 
@@ -136,15 +137,17 @@ But nothing is stopping you from throwing in any arbitrary code:
 expose :thing, id: ->{ 42 }
 ```
 
-Passing lambdas might not always be fun, so here are couple shortcuts that could
-help making life easier.
+Passing lambdas might not always be fun, so here are a couple of shortcuts that could
+help make life easier.
 
 ```ruby
-# equivalent to id: ->{ params[:custom_thing_id] }
 expose :thing, id: :custom_thing_id
+# equivalent to
+expose :thing, id: ->{ params[:custom_thing_id] }
 
-# equivalent to id: ->{ params[:try_this_id] || params[:or_maybe_that_id] }
 expose :thing, id: [:try_this_id, :or_maybe_that_id]
+# equivalent to
+expose :thing, id: ->{ params[:try_this_id] || params[:or_maybe_that_id] }
 ```
 
 ### `find`
@@ -160,7 +163,7 @@ Where `scope` is a model scope, like `Thing` or `User.active` or
 `Post.published`.
 
 Now, if you're using FriendlyId or Stringex or something similar, you'd have to
-customize your finding logic. You code might look somewhat like this:
+customize your finding logic. Your code might look somewhat like this:
 
 ```ruby
 expose :thing, find: ->(id, scope){ scope.find_by!(slug: id) }
@@ -184,10 +187,10 @@ expose :thing, build: ->(thing_params, scope){ scope.new(thing_params) }
 
 ### `build_params`
 
-This options is responsible for calulating params before passing it to the
+These options are responsible for calulating params before passing them to the
 build step. The default behavior was modeled with Strong Parameters in mind and
-is somewhat smart: it calls `thing_params` controller method if it's available
-and request method it not `GET`. In all other cases it produces an empty hash.
+is somewhat smart: it calls the `thing_params` controller method if it's available
+and the request method it not `GET`. In all other cases it produces an empty hash.
 
 You can easily specify which controller method you want it to call instead of
 `thing_params`, or just provide your own logic:
@@ -217,7 +220,7 @@ Like before, shortcuts are there to make you happier:
 
 ```ruby
 expose :post, scope: :published
-# fully equivalent to
+# equivalent to
 expose :post, scope: ->{ Post.published }
 ```
 
@@ -225,13 +228,13 @@ and
 
 ```ruby
 expose :thing, parent: :current_user
-# fully equivalent to:
+# equivalent to:
 expose :thing, scope: ->{ current_user.things }
 ```
 
 ### `model`
 
-Allows to specify the model class to use. Pretty straightforward.
+Allows you to specify the model class to use. Pretty straightforward.
 
 ```ruby
 expose :thing, model: ->{ AnotherThing }
@@ -250,6 +253,20 @@ that:
 expose :thing, decorate: ->(thing){ ThingDecorator.new(thing) }
 ```
 
+## `exposure_config`
+
+You can pre-save some configuration using `exposure_config` method reuse it
+later.
+
+```ruby
+exposure_config :cool_find, find: ->{ very_cool_find_code }
+exposure_config :cool_build, build: ->{ very_cool_build_code }
+
+expose :thing, with: [:cool_find, :cool_build]
+expose :another_thing, with: :cool_build
+```
+
+
 ## Contributing
 
 1. Fork it (https://github.com/rwz/adequate_exposure/fork)

data/lib/adequate_exposure/controller.rb

@@ -1,12 +1,23 @@
 module AdequateExposure
   module Controller
-    def expose(*args, &block)
-      Exposure.expose! self, *args, &block
-    end
+    extend ActiveSupport::Concern
+
+    included{ class_attribute :exposure_configuration }
+
+    module ClassMethods
+      def expose(*args, &block)
+        Exposure.expose! self, *args, &block
+      end
+
+      def expose!(name, *args, &block)
+        expose name, *args, &block
+        before_action name
+      end
 
-    def expose!(name, *args, &block)
-      expose name, *args, &block
-      before_action name
+      def exposure_config(name, options)
+        store = self.exposure_configuration ||= {}
+        self.exposure_configuration = store.merge(name => options)
+      end
     end
   end
 end

data/lib/adequate_exposure/exposure.rb

@@ -41,12 +41,51 @@ module AdequateExposure
     end
 
     def normalize_options
+      normalize_with_option
+      normalize_id_option
+      normalize_model_option
+      normalize_build_params_option
+      normalize_scope_options
+      normalize_parent_option
+      normalize_from_option
+      normalize_find_by_option
+    end
+
+    def normalize_find_by_option
+      if find_by = options.delete(:find_by)
+        merge_lambda_option :find, ->(id, scope){ scope.find_by!(find_by => id) }
+      end
+    end
+
+    def normalize_parent_option
+      exposure_name = options.fetch(:name)
+
+      if parent = options.delete(:parent)
+        merge_lambda_option :scope, ->{ send(parent).send(exposure_name.to_s.pluralize) }
+      end
+    end
+
+    def normalize_from_option
       exposure_name = options.fetch(:name)
 
+      if from = options.delete(:from)
+        merge_lambda_option :fetch, ->{ send(from).send(exposure_name) }
+      end
+    end
+
+    def normalize_with_option
+      if configs = options.delete(:with)
+        Array.wrap(configs).each{ |config| reverse_merge_config! config }
+      end
+    end
+
+    def normalize_id_option
       normalize_non_proc_option :id do |ids|
         ->{ Array.wrap(ids).map{ |id| params[id] }.find(&:present?) }
       end
+    end
 
+    def normalize_model_option
       normalize_non_proc_option :model do |value|
         model = if [String, Symbol].include?(value.class)
           value.to_s.classify.constantize
@@ -56,27 +95,19 @@ module AdequateExposure
 
         ->{ model }
       end
+    end
 
+    def normalize_build_params_option
       normalize_non_proc_option :build_params do |value|
         options[:build_params_method] = value
         nil
       end
+    end
 
+    def normalize_scope_options
       normalize_non_proc_option :scope do |custom_scope|
         ->(model){ model.send(custom_scope) }
       end
-
-      if parent = options.delete(:parent)
-        merge_lambda_option :scope, ->{ send(parent).send(exposure_name.to_s.pluralize) }
-      end
-
-      if from = options.delete(:from)
-        merge_lambda_option :fetch, ->{ send(from).send(exposure_name) }
-      end
-
-      if find_by = options.delete(:find_by)
-        merge_lambda_option :find, ->(id, scope){ scope.find_by!(find_by => id) }
-      end
     end
 
     def normalize_non_proc_option(name)
@@ -127,5 +158,10 @@ module AdequateExposure
         fail ArgumentError, "Using #{name.inspect} option with other options doesn't make sense"
       end
     end
+
+    def reverse_merge_config!(name)
+      config = controller.exposure_configuration.fetch(name)
+      options.reverse_merge! config
+    end
   end
 end

data/lib/adequate_exposure/version.rb

@@ -1,3 +1,3 @@
 module AdequateExposure
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/adequate_exposure.rb

@@ -8,6 +8,6 @@ module AdequateExposure
   autoload :Flow,       "adequate_exposure/flow"
 
   ActiveSupport.on_load :action_controller do
-    extend Controller
+    include Controller
   end
 end

data/spec/controller_spec.rb

@@ -14,7 +14,7 @@ describe AdequateExposure::Controller do
 
   let(:controller_klass) do
     Class.new(BaseController) do
-      extend AdequateExposure::Controller
+      include AdequateExposure::Controller
     end
   end
 
@@ -22,7 +22,7 @@ describe AdequateExposure::Controller do
   let(:controller){ controller_klass.new }
   before{ allow(controller).to receive(:request){ request } }
 
-  %w[expose expose!].each do |method_name|
+  %w[expose expose! exposure_config].each do |method_name|
     define_method method_name do |*args, &block|
       controller_klass.send method_name, *args, &block
     end
@@ -54,6 +54,45 @@ describe AdequateExposure::Controller do
     end
   end
 
+  context ".exposure_config" do
+    it "subclass configration doesn't propagate to superclass" do
+      controller_subklass = Class.new(controller_klass)
+      controller_klass.exposure_config :foo, :bar
+      controller_subklass.exposure_config :foo, :lol
+      controller_subklass.exposure_config :fizz, :buzz
+      expect(controller_subklass.exposure_configuration).to eq(foo: :lol, fizz: :buzz)
+      expect(controller_klass.exposure_configuration).to eq(foo: :bar)
+    end
+
+    context "applying" do
+      let(:thing){ double("Thing") }
+
+      before do
+        exposure_config :sluggable, find_by: :slug
+        exposure_config :weird_id_name, id: :check_this_out
+        exposure_config :another_id_name, id: :whee
+        controller.params.merge! check_this_out: "foo", whee: "wut"
+      end
+
+      after{ expect(controller.thing).to eq(thing) }
+
+      it "can be reused later" do
+        expose :thing, with: :weird_id_name
+        expect(Thing).to receive(:find).with("foo").and_return(thing)
+      end
+
+      it "can apply multple configs at once" do
+        expose :thing, with: [:weird_id_name, :sluggable]
+        expect(Thing).to receive(:find_by!).with(slug: "foo").and_return(thing)
+      end
+
+      it "applies multiple configs in a correct order" do
+        expose :thing, with: [:another_id_name, :weird_id_name]
+        expect(Thing).to receive(:find).with("wut").and_return(thing)
+      end
+    end
+  end
+
   context "with block" do
     before{ expose(:thing){ compute_thing } }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adequate_exposure
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Pavel Pravosud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties