adequate_exposure 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08518a93835d972d60b024e436f478f894b811c4
-  data.tar.gz: 7d0c3042b2d662a44e1d22ec6415fc46c1957078
+  metadata.gz: 331663a8f718896cab6be3800c0af9fc98379e8b
+  data.tar.gz: e942a3866cdd940adf9dd9e08e979b68b8456446
 SHA512:
-  metadata.gz: 3925a14260bd04bf95bba1e8785595ccb2771526b056f42bcc63e88978ab218520bc911462a61b124cef4df0c8103f08e1a2314c63e5623007552387d5786f8a
-  data.tar.gz: 027d750fbafb02bcee26be876daa877e04c033d5656a035c8df117f0289b8ffa5cc3f4becb93563e952f8b1a40ed95c5ac57efd797136eaebaa204af7389ccdd
+  metadata.gz: 4ce222e1500bce49ee95bc6eec47bc7f4956591070fba3b9acf5e5a3e3585296da02c79bb82c6532e65acf7049e39833709e8efe8032a8de58b18a6da26eaf59
+  data.tar.gz: 9e292f24fbf0242ee15b8bb41483a2aa73def2316373612645d94c99592430c31ba41bfc3be9d243326e29f5ee62084ec7e408b3da4b12a5201dd07dcf7645d2

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9
+  - 2.0
+  - 2.1

data/README.md

@@ -1,22 +1,23 @@
 # Adequate Exposure
-
-This is WIP. Please don't send pull requests yet, I'm still actively rewriting things.
+[![Gem Version](https://img.shields.io/gem/v/adequate_exposure.svg)](https://rubygems.org/gems/adequate_exposure)
+[![Build Status](https://img.shields.io/travis/rwz/adequate_exposure.svg)](http://travis-ci.org/rwz/adequate_exposure)
+[![Code Climate](https://img.shields.io/codeclimate/github/rwz/adequate_exposure.svg)](https://codeclimate.com/github/rwz/adequate_exposure)
 
 Exposing things, adequately.
 
 Adequate exposure is a lightweight alternative to [Decent
-Exposure](https://github.com/voxdolo/decent_exposure). With it's narrowly
+Exposure](https://github.com/voxdolo/decent_exposure). With its 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.)*
+inadequate.*
 
 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.
+The whole API consists of two methods so far: `expose` and `expose!`.
 
 In the simplest scenario you'll just use it to expose a model in the
 controller:
@@ -28,28 +29,29 @@ 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.
+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
 expressed with the following pseudocode:
 
 ```ruby
 def fetch(scope, id)
-  instance = id ? find(id, scope) : build(scope)
+  instance = id ? find(id, scope) : build(build_params, scope)
   decorate(instance)
 end
 
 def id
-  params[:id] || params[:thing_id]
+  params[:thing_id] || params[:id]
 end
 
 def find(id, scope)
-  scope.find(id) # Thing.find(id)
+  scope.find(id)
 end
 
-def build(scope)
-  scope.new(build_params) # Thing.new(thing_params)
+def build(params, scope)
+  scope.new(params) # Thing.new(params)
 end
 
 def scope
@@ -73,75 +75,176 @@ def decorate(thing)
 end
 ```
 
+The exposure is also lazy, which means that it won't do anything until you call
+the method. To eliminate this lazyness you can use `expose!` macro instead,
+which will try to resolve the exposure in a before filter.
+
 Each step could be overrided with options. The acceptable options to the
 `expose` macro are:
 
-**fetch**
+### `fetch`
 
-This is the entry point. Fetch proc defines how to resolve your exposure in the
-first place.
+This is the entry point. The `fetch` proc defines how to resolve your exposure
+in the first place.
 
 ```ruby
 expose :thing, fetch: ->{ get_thing_some_way_or_another }
 ```
 
-**find**
+Because the above behavior overrides the normal workflow, all other options
+would be ignored. However, Adequate Exposure is decent enough to actually blow
+up with an error so you don't accidentally do this.
 
-Defines how to perform the finding. Could be useful if you don't want to use standard
-Rails finder.
+There are other less verbose ways to pass the `fetch` block, since you'll
+probably be using it often:
 
 ```ruby
-expose :thing, find: ->(id, scope){ scope.find_by(slug: id) }
+expose(:thing){ get_thing_some_way_or_another }
 ```
 
-**build**
+Or if you (like me) absolutely hate parens in side-effect methods:
 
-Allows to override the build process that takes place when id is not provided.
+```ruby
+expose :thing, ->{ get_thing_some_way_or_another }
+```
+
+There is another shortcut that allows you to redefine entire fetch block with
+less code:
 
 ```ruby
-expose :thing, build: ->(scope){ Thing.build_with_defaults }
+expose :comments, from: :post
+# equivalent to 
+expose :comments, ->{ post.comments }
 ```
 
-**id**
+### `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.
 
-Specifies how to extract id from parameters hash.
+Default behavior could be expressed using following code:
 
 ```ruby
-# default
 expose :thing, id: ->{ params[:thing_id] || params[:id] }
+```
 
-# id is always goona be 42
+But nothing is stopping you from throwing in any arbitrary code:
+
+```ruby
+# id is always gonna be the answer to ultimate question of life, the universe,
+# and everyting
 expose :thing, id: ->{ 42 }
+```
 
+Passing lambdas might not always be fun, so here are couple shortcuts that could
+help making life easier.
+
+```ruby
 # equivalent to id: ->{ params[:custom_thing_id] }
 expose :thing, id: :custom_thing_id
 
 # equivalent to id: ->{ params[:try_this_id] || params[:or_maybe_that_id] }
-expose :thing, id: %i[try_this_id or_maybe_that_id]
+expose :thing, id: [:try_this_id, :or_maybe_that_id]
+```
+
+### `find`
+
+If an ID was provided, Adequate Exposure will try to find the model using it.
+Default behavior could be expressed with this configuration: 
+
+```ruby
+expose :thing, find: ->(id, scope){ scope.find(id) }
+```
+
+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:
+
+```ruby
+expose :thing, find: ->(id, scope){ scope.find_by!(slug: id) }
+```
+
+Again, because this is likely to happen a lot, Adequate Exposure gives you a
+decent shortcut so you can get more done by typing less.
+
+```ruby
+expose :thing, find_by: :slug
 ```
 
-**scope**
+### `build`
+
+When an ID is not present, Adequate Exposure tries to build an object for you. By
+default, it behaves like this:
+
+```ruby
+expose :thing, build: ->(thing_params, scope){ scope.new(thing_params) }
+```
+
+### `build_params`
+
+This options is responsible for calulating params before passing it 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.
+
+You can easily specify which controller method you want it to call instead of
+`thing_params`, or just provide your own logic:
+
+```ruby
+expose :thing, build_params: :custom_thing_params
+expose :other_thing, build_params: ->{ { foo: "bar" } }
+
+private
+
+def custom_thing_params
+  # strong parameters stuff goes here
+end
+```
+
+### `scope`
 
 Defines the scope that's used in `find` and `build` steps.
 
 ```ruby
 expose :thing, scope: ->{ current_user.things }
+expose :user, scope: ->{ User.active }
+expose :post, scope: ->{ Post.published }
+```
+
+Like before, shortcuts are there to make you happier:
+
+```ruby
+expose :post, scope: :published
+# fully equivalent to
+expose :post, scope: ->{ Post.published }
+```
+
+and
+
+```ruby
+expose :thing, parent: :current_user
+# fully equivalent to:
+expose :thing, scope: ->{ current_user.things }
 ```
 
-**model**
+### `model`
 
-Specify the model class to use.
+Allows to specify the model class to use. Pretty straightforward.
 
 ```ruby
 expose :thing, model: ->{ AnotherThing }
 expose :thing, model: AnotherThing
+expose :thing, model: "AnotherThing"
 expose :thing, model: :another_thing
 ```
 
+### `decorate`
 
-**decorate**
-
-Allows to define a block that wraps an instance before it's returned. Useful for decorators.
+Before returning the thing, Adequate Exposure will run it through the
+decoration process. Initially, this does nothing, but you can obviously change
+that:
 
 ```ruby
 expose :thing, decorate: ->(thing){ ThingDecorator.new(thing) }

data/adequate_exposure.gemspec

@@ -1,6 +1,4 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "adequate_exposure/version"
 
 Gem::Specification.new do |spec|
@@ -15,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.test_files   = spec.files.grep(/\Aspec\//)
   spec.require_path = "lib"
 
-  spec.required_ruby_version = "~> 2.0"
+  spec.required_ruby_version = ">= 1.9.3"
 
   spec.add_dependency "railties",      "~> 4.0"
   spec.add_dependency "activesupport", "~> 4.0"

data/lib/adequate_exposure/attribute.rb

@@ -2,8 +2,10 @@ module AdequateExposure
   class Attribute
     attr_reader :name, :fetch, :ivar_name
 
-    def initialize(name:, fetch:, ivar_name:)
-      @name, @fetch, @ivar_name = name, fetch, ivar_name
+    def initialize(options)
+      @name = options.fetch(:name)
+      @fetch = options.fetch(:fetch)
+      @ivar_name = options.fetch(:ivar_name)
     end
 
     def getter_method_name

data/lib/adequate_exposure/exposure.rb

@@ -6,8 +6,10 @@ module AdequateExposure
       new(*args, &block).expose!
     end
 
-    def initialize(controller, name, fetch_block=nil, **options, &block)
+    def initialize(controller, name, *args, &block)
       @controller = controller
+      options = args.extract_options!
+      fetch_block = args.pop
       @options = options.with_indifferent_access.merge(name: name)
 
       merge_lambda_option :fetch, fetch_block if fetch_block

data/lib/adequate_exposure/flow.rb

@@ -11,7 +11,7 @@ module AdequateExposure
       options.fetch(:name)
     end
 
-    %i[fetch find build build_params scope model id decorate].each do |method_name|
+    %w[fetch find build build_params scope model id decorate].each do |method_name|
       define_method method_name do |*args|
         ivar_name = "@#{method_name}"
         return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
@@ -23,7 +23,7 @@ module AdequateExposure
 
     def default_fetch
       computed_scope = scope(model)
-      instance = id ? find(id, computed_scope) : build(computed_scope)
+      instance = id ? find(id, computed_scope) : build(build_params, computed_scope)
       decorate(instance)
     end
 
@@ -43,8 +43,8 @@ module AdequateExposure
       scope.find(id)
     end
 
-    def default_build(scope)
-      scope.new(build_params)
+    def default_build(params, scope)
+      scope.new(params)
     end
 
     def default_decorate(instance)

data/lib/adequate_exposure/version.rb

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

data/spec/controller_spec.rb

@@ -22,7 +22,7 @@ describe AdequateExposure::Controller do
   let(:controller){ controller_klass.new }
   before{ allow(controller).to receive(:request){ request } }
 
-  %i[expose expose!].each do |method_name|
+  %w[expose expose!].each do |method_name|
     define_method method_name do |*args, &block|
       controller_klass.send method_name, *args, &block
     end
@@ -274,7 +274,7 @@ describe AdequateExposure::Controller do
     end
 
     it "allows overriding id with an array of symbols" do
-      expose :thing, id: %i[non-existent-id lolwut another_id_param]
+      expose :thing, id: %w[non-existent-id lolwut another_id_param]
       controller.params.merge! another_id_param: 42
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adequate_exposure
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Pavel Pravosud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -46,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -72,9 +73,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="