adequate_exposure 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a1d34ba1b491cb226abd1ed966b2e1fc51469a5
-  data.tar.gz: f5a79cc81e6918171764fe3441f81e7da2a372bd
+  metadata.gz: 82a9cfe00dccb013cca09b85f68073902bb5928d
+  data.tar.gz: 15ec7db35c84401f82a3d8bab5af8079ccf5ea81
 SHA512:
-  metadata.gz: 332ca67a8253cbb83e395a95bc79167a9ac355843a772adf1b373569c83086afcc2daed5eb30bbae058a4d57b9fe73992a28d3acaadcc60bac04f47f7bb8eb5d
-  data.tar.gz: 2558b8622f561444eae1ba3b1c19d46b059cd83f2fe0705e06af4e33bb93e821392b6f02a5d11ebcda03fee01b162066072e60e66fa4cebff0dbdc02b6c01abb
+  metadata.gz: 8ade244f9a2785594a66b5ba042b2639a15157eb39f72234f3e2133d21a27bffe2dcecf3d61a6a79d9768b4a0d6ab5605cd3336600c3d49e848767708385c22a
+  data.tar.gz: 84260440dbd08e8444ce307994f4c564e97b76efc48a5e554d349a5018ba8c3d7d4ec0cf7801d860876cd306ba014ef1b5c2ff0f396b3ded2fdbe1faaedd7660

data/README.md

@@ -2,19 +2,24 @@
 
 This is WIP. Please don't send pull requests yet, I'm still actively rewriting things.
 
-Adequate exposure. Exposing things, adequately.
+Exposing things, adequately.
 
-Adequate exposure is a lightweight alternative to [Decent Exposure](https://github.com/voxdolo/decent_exposure). With it's narrowly focused api you can get exactly what you need without all the extra dressing.
+Adequate exposure is a lightweight alternative to [Decent
+Exposure](https://github.com/voxdolo/decent_exposure). With it's narrowly
+focused api you can get exactly what you need without all the extra dressing.
 
-*Note: It is not the intent of the author to imply that Decent Exposure is inadequate.)*
+*Note: It is not the intent of the author to imply that Decent Exposure is
+inadequate.)*
 
-Installation is as simple as: `$ gem install adequate_exposure`. Once you have that down we can start talking about the API.
+Installation is as simple as: `$ gem install adequate_exposure`. Once you have
+that down we can start talking about the API.
 
 ## API
 
 The whole API consists of one `expose` method.
 
-In the simplest scenario you'll just use it to expose a model in the controller:
+In the simplest scenario you'll just use it to expose a model in the
+controller:
 
 ```ruby
 class ThingsController < ApplicationController
@@ -22,23 +27,12 @@ class ThingsController < ApplicationController
 end
 ```
 
-Now every time you call `thing` in your controller or view, it'll look for an id and try to perform `Thing.find(id)` or `Thing.new` if the id is not found. It'll also memoize the result in `@exposed_thing` instance variable.
+Now every time you call `thing` in your controller or view, it'll look for an
+id and try to perform `Thing.find(id)` or `Thing.new` if the id is not found.
+It'll also memoize the result in `@exposed_thing` instance variable.
 
-You can also provide your own logic of how `thing` should be resolved by passing a block that'll be executed in your controller context.
-
-```ruby
-class ThingsController < ApplicationController
-  expose(:thing){ Thing.find(get_thing_id_somehow) }
-  
-  private
-  
-  def get_thing_id_somehow
-    42
-  end
-end
-```
-
-The default resolving workflow if pretty powerful and customizable. It could be expressed with the following pseudocode:
+The default resolving workflow if pretty powerful and customizable. It could be
+expressed with the following pseudocode:
 
 ```ruby
 def fetch(scope, id)
@@ -70,11 +64,22 @@ def decorate(thing)
 end
 ```
 
-Each step is overridable with options. The acceptable options to the `expose` macro are:
+Each step could be overrided with options. The acceptable options to the
+`expose` macro are:
+
+**fetch**
+
+This is the entry point. Fetch proc defines how to resolve your exposure in the
+first place.
+
+```ruby
+expose :thing, fetch: ->{ get_thing_some_way_or_another }
+```
 
 **find**
 
-How to perform the finding. Could be useful if you don't want to use standard Rails finder.
+Defines how to perform the finding. Could be useful if you don't want to use standard
+Rails finder.
 
 ```ruby
 expose :thing, find: ->(id, scope){ scope.find_by(slug: id) }
@@ -90,7 +95,7 @@ expose :thing, build: ->(scope){ Thing.build_with_defaults }
 
 **id**
 
-Allows to specify how to extract id from parameters hash.
+Specifies how to extract id from parameters hash.
 
 ```ruby
 # default
@@ -112,12 +117,11 @@ Defines the scope that's used in `find` and `build` steps.
 
 ```ruby
 expose :thing, scope: ->{ current_user.things }
-expose :thing, scope: :current_user # the same as above
 ```
 
 **model**
 
-Specify the model to use.
+Specify the model class to use.
 
 ```ruby
 expose :thing, model: ->{ AnotherThing }
@@ -125,18 +129,10 @@ expose :thing, model: AnotherThing
 expose :thing, model: :another_thing
 ```
 
-**fetch**
-
-Allows to override the `fetch` logic that's happening when you first call exposed helper.
-
-```ruby
-expose :thing, fetch: ->{ get_thing_some_way_or_another }
-expose(:thing){ get_thing_some_way_or_another }
-```
 
 **decorate**
 
-Allows to define a block that wraps and instance before it's returned. Useful for decorators.
+Allows to define a block that wraps an instance before it's returned. Useful for decorators.
 
 ```ruby
 expose :thing, decorate: ->(thing){ ThingDecorator.new(thing) }
@@ -144,7 +140,7 @@ expose :thing, decorate: ->(thing){ ThingDecorator.new(thing) }
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/adequate_exposure/fork )
+1. Fork it (https://github.com/rwz/adequate_exposure/fork)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/adequate_exposure.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   spec.version      = AdequateExposure::VERSION
   spec.authors      = ["Pavel Pravosud"]
   spec.email        = ["pavel@pravosud.com"]
-  spec.summary      = "More adequate than decent"
+  spec.summary      = "Exposing things, adequately"
   spec.homepage     = "https://github.com/rwz/adequate_exposure"
   spec.license      = "MIT"
   spec.files        = `git ls-files -z`.split("\x0")

data/lib/adequate_exposure/context.rb

@@ -1,5 +1,3 @@
-require "active_support/core_ext/module/delegation"
-
 module AdequateExposure
   class Context
     attr_reader :context, :attribute

data/lib/adequate_exposure/controller.rb

@@ -1,11 +1,12 @@
-require "active_support/core_ext/hash/reverse_merge"
-
 module AdequateExposure
   module Controller
-    def expose(name, **options, &block)
-      options = options.merge(name: name)
-      options.reverse_merge! fetch: block if block_given?
-      Exposure.new(options).expose! self
+    def expose(*args, &block)
+      Exposure.expose! self, *args, &block
+    end
+
+    def expose!(name, *args, &block)
+      expose name, *args, &block
+      before_action name
     end
   end
 end

data/lib/adequate_exposure/exposure.rb

@@ -1,27 +1,92 @@
 module AdequateExposure
   class Exposure
-    attr_reader :options
+    attr_reader :controller, :options
 
-    def initialize(options)
-      @options = options
+    def self.expose!(*args, &block)
+      new(*args, &block).expose!
     end
 
-    def expose!(controller)
-      expose_attribute! controller
-      expose_helper_methods! controller
+    def initialize(controller, name, fetch_block=nil, **options, &block)
+      @controller = controller
+      @options = options.with_indifferent_access.merge(name: name)
+
+      merge_lambda_option :fetch, fetch_block if fetch_block
+      merge_lambda_option :fetch, block if block_given?
+
+      assert_singleton_option :fetch
+      assert_singleton_option :from
+      assert_incompatible_options_pair :parent, :model
+      assert_incompatible_options_pair :parent, :scope
+
+      normalize_options
+    end
+
+    def expose!
+      expose_attribute!
+      expose_helper_methods!
     end
 
     private
 
-    def expose_attribute!(controller)
+    def expose_attribute!
       attribute.expose! controller
     end
 
-    def expose_helper_methods!(controller)
+    def expose_helper_methods!
       helper_methods = [ attribute.getter_method_name, attribute.setter_method_name ]
       controller.helper_method *helper_methods
     end
 
+    def normalize_options
+      exposure_name = options.fetch(:name)
+
+      normalize_non_proc_option :id do |ids|
+        ->{ Array.wrap(ids).map{ |id| params[id] }.find(&:present?) }
+      end
+
+      normalize_non_proc_option :model do |value|
+        model = if [String, Symbol].include?(value.class)
+          value.to_s.classify.constantize
+        else
+          value
+        end
+
+        ->{ model }
+      end
+
+      normalize_non_proc_option :build do |params_method_name|
+        ->(scope){ scope.new(send(params_method_name)) }
+      end
+
+      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
+    end
+
+    def normalize_non_proc_option(name)
+      option_value = options[name]
+      return if Proc === option_value
+      if option_value.present?
+        merge_lambda_option name, yield(option_value)
+      end
+    end
+
+    def merge_lambda_option(name, body)
+      if previous_value = options[name] and Proc === previous_value
+        fail ArgumentError, "#{name.to_s.titleize} block is already defined"
+      end
+
+      options[name] = body
+    end
+
     def attribute
       @attribute ||= begin
         local_options = options
@@ -37,5 +102,17 @@ module AdequateExposure
         )
       end
     end
+
+    def assert_incompatible_options_pair(key1, key2)
+      if options.key?(key1) && options.key?(key2)
+        fail ArgumentError, "Using #{key1.inspect} option with #{key2.inspect} doesn't make sense"
+      end
+    end
+
+    def assert_singleton_option(name)
+      if options.except(name, :name).any? && options.key?(name)
+        fail ArgumentError, "Using #{name.inspect} option with other options doesn't make sense"
+      end
+    end
   end
 end

data/lib/adequate_exposure/flow.rb

@@ -1,14 +1,10 @@
-require "active_support/hash_with_indifferent_access"
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/string/inflections"
-
 module AdequateExposure
   class Flow
     attr_reader :controller, :options
     delegate :params, to: :controller
 
-    def initialize(controller, **options)
-      @controller, @options = controller, HashWithIndifferentAccess.new(options)
+    def initialize(controller, options)
+      @controller, @options = controller, options.with_indifferent_access
     end
 
     def name
@@ -26,19 +22,20 @@ module AdequateExposure
     protected
 
     def default_fetch
-      id ? decorate(find(id, scope)) : decorate(build(scope))
+      computed_scope = scope(model)
+      id ? decorate(find(id, computed_scope)) : decorate(build(computed_scope))
     end
 
     def default_id
-      fetch_first_defined_param %I[#{name}_id id]
+      params["#{name}_id"] || params[:id]
     end
 
-    def default_scope
+    def default_scope(model)
       model
     end
 
     def default_model
-      symbol_to_class(name)
+      name.to_s.classify.constantize
     end
 
     def default_find(id, scope)
@@ -46,32 +43,25 @@ module AdequateExposure
     end
 
     def default_build(scope)
-      scope.new
+      scope.new(exposure_params)
     end
 
     def default_decorate(instance)
       instance
     end
 
-    def handle_custom_model(value)
-      Class === value ? value : symbol_to_class(value)
-    end
-
-    def handle_custom_scope(value)
-      scope_parent = controller.instance_exec{ send value }
-      scope_parent.send(name.to_s.pluralize)
-    end
+    def exposure_params
+      params_method_name = "#{name}_params"
 
-    def handle_custom_id(value)
-      fetch_first_defined_param value
+      if controller.respond_to?(params_method_name, true)
+        controller.send(params_method_name)
+      else
+        {}
+      end
     end
 
     private
 
-    def id_attribute_name
-      Array.wrap(possible_id_keys).detect{ |key| params.key?(key) }
-    end
-
     def handle_action(name, *args)
       if options.key?(name)
         handle_custom_action(name, *args)
@@ -84,22 +74,11 @@ module AdequateExposure
       value = options[name]
 
       if Proc === value
+        args = args.first(value.parameters.length)
         controller.instance_exec(*args, &value)
       else
-        send("handle_custom_#{name}", value, *args)
+        fail ArgumentError, "Can't handle #{name.inspect} => #{value.inspect} option"
       end
     end
-
-    def symbol_to_class(symbol)
-      symbol.to_s.classify.constantize
-    end
-
-    def fetch_first_defined_param(keys)
-      Array.wrap(keys).each do |key|
-        return params[key] if params.key?(key)
-      end
-
-      nil
-    end
   end
 end

data/lib/adequate_exposure/version.rb

@@ -1,3 +1,3 @@
 module AdequateExposure
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/adequate_exposure.rb

@@ -1,4 +1,4 @@
-require "active_support/lazy_load_hooks"
+require "active_support/all"
 
 module AdequateExposure
   autoload :Controller, "adequate_exposure/controller"

data/spec/controller_spec.rb

@@ -43,10 +43,15 @@ describe AdequateExposure::Controller do
     end
   end
 
-  context "with block" do
-    before do
-      expose(:thing){ compute_thing }
+  context ".expose!" do
+    it "supports eager expose" do
+      expect(controller_klass).to receive(:before_action).with(:thing)
+      controller_klass.expose! :thing
     end
+  end
+
+  context "with block" do
+    before{ expose(:thing){ compute_thing } }
 
     it "executes block to calculate the value" do
       allow(controller).to receive(:compute_thing).and_return(42)
@@ -63,6 +68,24 @@ describe AdequateExposure::Controller do
       controller.thing = :foobar
       expect(controller.thing).to eq(:foobar)
     end
+
+    it "throws and error when providing options with block" do
+      action = ->{ expose(:thing, id: :some_id){ some_code } }
+      expect(&action).to raise_error(ArgumentError, "Using :fetch option with other options doesn't make sense")
+    end
+  end
+
+  context "passing fetch block as an argument instead of block" do
+    it "is equivalent to passing block" do
+      expose :thing, ->{ compute_thing }
+      expect(controller).to receive(:compute_thing).and_return(42)
+      expect(controller.thing).to eq(42)
+    end
+
+    it "throws an error when passing both block and block-argument" do
+      action = ->{ expose(:thing, ->{}){} }
+      expect(&action).to raise_error(ArgumentError, "Fetch block is already defined")
+    end
   end
 
   context "redefine fetch" do
@@ -77,14 +100,36 @@ describe AdequateExposure::Controller do
   end
 
   context "default behaviour" do
-    before{ expose :thing }
 
-    it "builds a new instance when id is not provided" do
-      expect(controller.thing).to be_instance_of(Thing)
+    context "build" do
+      let(:thing){ double("Thing") }
+
+      after{ expect(controller.thing).to eq(thing) }
+
+      it "builds a new instance with empty hash when strong parameters method is not available" do
+        expose :thing
+        expect(Thing).to receive(:new).with({}).and_return(thing)
+      end
+
+      it "builds a new instance with attributes when strong parameters method is available" do
+        expose :thing
+        expect(Thing).to receive(:new).with(foo: :bar).and_return(thing)
+        expect(controller).to receive(:thing_params).and_return(foo: :bar)
+      end
+
+      it "allows to specify strong parameters method name with a symbol passed to build option" do
+        expose :thing, build: :custom_params_method_name
+        expect(Thing).to receive(:new).with(foo: :bar).and_return(thing)
+        expect(controller).to receive(:custom_params_method_name).and_return(foo: :bar)
+      end
     end
 
     context "find" do
-      before{ expect(Thing).to receive(:find).with(10) }
+      before do
+        expose :thing
+        expect(Thing).to receive(:find).with(10)
+      end
+
       after{ controller.thing }
 
       it "finds Thing if thing_id param is provided" do
@@ -97,8 +142,46 @@ describe AdequateExposure::Controller do
     end
   end
 
+  context "parent option" do
+    context "with scope/model options" do
+      it "throws an error when used with scope option" do
+        action = ->{ expose :thing, scope: :foo, parent: :something }
+        expect(&action).to raise_error(ArgumentError, "Using :parent option with :scope doesn't make sense")
+      end
+
+      it "throws an error when used with model option" do
+        action = ->{ expose :thing, model: :foo, parent: :something }
+        expect(&action).to raise_error(ArgumentError, "Using :parent option with :model doesn't make sense")
+      end
+    end
+
+    context "build/find" do
+      let(:current_user){ double("User") }
+      let(:scope){ double("Scope") }
+
+      before do
+        expect(controller).to receive(:current_user).and_return(current_user)
+        expect(current_user).to receive(:things).and_return(scope)
+        expose :thing, parent: :current_user
+      end
+
+      after{ expect(controller.thing).to eq(42) }
+
+      it "sets the scope to belong to parent defined by controller method" do
+        expect(scope).to receive(:new).with({}).and_return(42)
+      end
+
+      it "scopes the find to proper scope" do
+        controller.params.merge! thing_id: 10
+        expect(scope).to receive(:find).with(10).and_return(42)
+      end
+    end
+  end
+
   context "override model" do
-    after{ expect(controller.thing).to be_instance_of(DifferentThing) }
+    let(:different_thing){ double("DifferentThing") }
+    before{ expect(DifferentThing).to receive(:new).with({}).and_return(different_thing) }
+    after{ expect(controller.thing).to eq(different_thing) }
 
     it "allows overriding model class with proc" do
       expose :thing, model: ->{ DifferentThing }
@@ -111,6 +194,10 @@ describe AdequateExposure::Controller do
     it "allows overriding model class with symbol" do
       expose :thing, model: :different_thing
     end
+
+    it "allows overriding model class with string" do
+      expose :thing, model: "DifferentThing"
+    end
   end
 
   context "override scope" do
@@ -121,17 +208,12 @@ describe AdequateExposure::Controller do
       expect(controller.thing).to eq(42)
     end
 
-    it "allows overriding with symbol" do
-      current_user = double("User")
+    it "allows overriding model scope using symbol" do
       scope = double("Scope")
-      scoped_thing = double("Thing")
-
-      expect(controller).to receive(:current_user).and_return(current_user)
-      expect(current_user).to receive(:things).and_return(scope)
-      expect(scope).to receive(:new).and_return(scoped_thing)
-      expose :thing, scope: :current_user
-
-      expect(controller.thing).to eq(scoped_thing)
+      expect(Thing).to receive(:custom_scope).and_return(scope)
+      expect(scope).to receive(:new).and_return(42)
+      expose :thing, scope: :custom_scope
+      expect(controller.thing).to eq(42)
     end
   end
 
@@ -160,8 +242,27 @@ describe AdequateExposure::Controller do
   context "override decorator" do
     it "allows specify decorator" do
       expose :thing, decorate: ->(thing){ decorate(thing) }
-      expect(controller).to receive(:decorate).with(an_instance_of(Thing))
+      thing = double("Thing")
+      expect(Thing).to receive(:new).with({}).and_return(thing)
+      expect(controller).to receive(:decorate).with(thing)
       controller.thing
     end
   end
+
+  context "from option" do
+    it "allows scope to be called from method" do
+      post = double("Post")
+      comments = double("Comments")
+      allow(controller).to receive(:post).and_return(post)
+      expect(post).to receive(:comments).and_return(comments)
+      expose :comments, from: :post
+
+      expect(controller.comments).to eq(comments)
+    end
+
+    it "should throw error when used with other options" do
+      action = ->{ expose :thing, from: :foo, parent: :bar }
+      expect(&action).to raise_error(ArgumentError, "Using :from option with other options doesn't make sense")
+    end
+  end
 end

data/spec/support/rails_app.rb

@@ -1,5 +1,4 @@
 require "active_support/all"
-require "active_support/dependencies/autoload"
 require "action_controller"
 require "action_dispatch"
 require "rails"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adequate_exposure
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Pavel Pravosud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-02 00:00:00.000000000 Z
+date: 2014-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -85,7 +85,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: More adequate than decent
+summary: Exposing things, adequately
 test_files:
 - spec/controller_spec.rb
 - spec/integration_spec.rb