adequate_exposure 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a1d34ba1b491cb226abd1ed966b2e1fc51469a5
+  data.tar.gz: f5a79cc81e6918171764fe3441f81e7da2a372bd
+SHA512:
+  metadata.gz: 332ca67a8253cbb83e395a95bc79167a9ac355843a772adf1b373569c83086afcc2daed5eb30bbae058a4d57b9fe73992a28d3acaadcc60bac04f47f7bb8eb5d
+  data.tar.gz: 2558b8622f561444eae1ba3b1c19d46b059cd83f2fe0705e06af4e33bb93e821392b6f02a5d11ebcda03fee01b162066072e60e66fa4cebff0dbdc02b6c01abb

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rspec-rails", "~> 3.0"
+gem "rake",        "~> 10.3"
+gem "pry"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Hashrocket Workstation
+
+MIT License
+
+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,151 @@
+# Adequate Exposure
+
+This is WIP. Please don't send pull requests yet, I'm still actively rewriting things.
+
+Adequate exposure. 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.
+
+*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.
+
+## 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:
+
+```ruby
+class ThingsController < ApplicationController
+  expose :thing
+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.
+
+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:
+
+```ruby
+def fetch(scope, id)
+  id ? decorate(find(id, scope)) : decorate(build(scope))
+end
+
+def id
+  params[:thing_id] || params[:id]
+end
+
+def find(id, scope)
+  scope.find(id) # Thing.find(id)
+end
+
+def build(scope)
+  scope.new # Thing.new
+end
+
+def scope
+  model # Thing
+end
+
+def model
+  exposure_name.classify.constantize # :thing -> Thing
+end
+
+def decorate(thing)
+  thing
+end
+```
+
+Each step is overridable with options. The acceptable options to the `expose` macro are:
+
+**find**
+
+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) }
+```
+
+**build**
+
+Allows to override the build process that takes place when id is not provided.
+
+```ruby
+expose :thing, build: ->(scope){ Thing.build_with_defaults }
+```
+
+**id**
+
+Allows to specify how to extract id from parameters hash.
+
+```ruby
+# default
+expose :thing, id: ->{ params[:thing_id] || params[:id] }
+
+# id is always goona be 42
+expose :thing, id: ->{ 42 }
+
+# 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]
+```
+
+**scope**
+
+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.
+
+```ruby
+expose :thing, model: ->{ AnotherThing }
+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.
+
+```ruby
+expose :thing, decorate: ->(thing){ ThingDecorator.new(thing) }
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/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`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task default: :spec

data/adequate_exposure.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "adequate_exposure/version"
+
+Gem::Specification.new do |spec|
+  spec.name         = "adequate_exposure"
+  spec.version      = AdequateExposure::VERSION
+  spec.authors      = ["Pavel Pravosud"]
+  spec.email        = ["pavel@pravosud.com"]
+  spec.summary      = "More adequate than decent"
+  spec.homepage     = "https://github.com/rwz/adequate_exposure"
+  spec.license      = "MIT"
+  spec.files        = `git ls-files -z`.split("\x0")
+  spec.test_files   = spec.files.grep(/\Aspec\//)
+  spec.require_path = "lib"
+
+  spec.required_ruby_version = "~> 2.0"
+
+  spec.add_dependency "railties",      "~> 4.0"
+  spec.add_dependency "activesupport", "~> 4.0"
+end

data/lib/adequate_exposure.rb

@@ -0,0 +1,13 @@
+require "active_support/lazy_load_hooks"
+
+module AdequateExposure
+  autoload :Controller, "adequate_exposure/controller"
+  autoload :Exposure,   "adequate_exposure/exposure"
+  autoload :Attribute,  "adequate_exposure/attribute"
+  autoload :Context,    "adequate_exposure/context"
+  autoload :Flow,       "adequate_exposure/flow"
+
+  ActiveSupport.on_load :action_controller do
+    extend Controller
+  end
+end

data/lib/adequate_exposure/attribute.rb

@@ -0,0 +1,31 @@
+module AdequateExposure
+  class Attribute
+    attr_reader :name, :fetch, :ivar_name
+
+    def initialize(name:, fetch:, ivar_name:)
+      @name, @fetch, @ivar_name = name, fetch, ivar_name
+    end
+
+    def getter_method_name
+      name.to_sym
+    end
+
+    def setter_method_name
+      "#{name}=".to_sym
+    end
+
+    def expose!(klass)
+      attribute = self
+
+      klass.instance_eval do
+        define_method attribute.getter_method_name do
+          Context.new(self, attribute).get
+        end
+
+        define_method attribute.setter_method_name do |value|
+          Context.new(self, attribute).set(value)
+        end
+      end
+    end
+  end
+end

data/lib/adequate_exposure/context.rb

@@ -0,0 +1,44 @@
+require "active_support/core_ext/module/delegation"
+
+module AdequateExposure
+  class Context
+    attr_reader :context, :attribute
+
+    def initialize(context, attribute)
+      @context, @attribute = context, attribute
+    end
+
+    def get
+      ivar_defined?? ivar_get : set(fetch_value)
+    end
+
+    def set(value)
+      ivar_set(value)
+    end
+
+    private
+
+    delegate :instance_variable_set, :instance_variable_get,
+      :instance_variable_defined?, to: :context
+
+    def ivar_defined?
+      instance_variable_defined?(ivar_name)
+    end
+
+    def ivar_get
+      instance_variable_get(ivar_name)
+    end
+
+    def ivar_set(value)
+      instance_variable_set(ivar_name, value)
+    end
+
+    def ivar_name
+      "@#{attribute.ivar_name}"
+    end
+
+    def fetch_value
+      context.instance_exec(&attribute.fetch)
+    end
+  end
+end

data/lib/adequate_exposure/controller.rb

@@ -0,0 +1,11 @@
+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
+    end
+  end
+end

data/lib/adequate_exposure/exposure.rb

@@ -0,0 +1,41 @@
+module AdequateExposure
+  class Exposure
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def expose!(controller)
+      expose_attribute! controller
+      expose_helper_methods! controller
+    end
+
+    private
+
+    def expose_attribute!(controller)
+      attribute.expose! controller
+    end
+
+    def expose_helper_methods!(controller)
+      helper_methods = [ attribute.getter_method_name, attribute.setter_method_name ]
+      controller.helper_method *helper_methods
+    end
+
+    def attribute
+      @attribute ||= begin
+        local_options = options
+
+        name = options.fetch(:name)
+        ivar_name = "exposed_#{name}"
+        fetch = ->{ Flow.new(self, local_options).fetch }
+
+        Attribute.new(
+          name: name,
+          ivar_name: ivar_name,
+          fetch: fetch
+        )
+      end
+    end
+  end
+end

data/lib/adequate_exposure/flow.rb

@@ -0,0 +1,105 @@
+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)
+    end
+
+    def name
+      options.fetch(:name)
+    end
+
+    %i[fetch find build 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)
+        instance_variable_set(ivar_name, handle_action(method_name, *args))
+      end
+    end
+
+    protected
+
+    def default_fetch
+      id ? decorate(find(id, scope)) : decorate(build(scope))
+    end
+
+    def default_id
+      fetch_first_defined_param %I[#{name}_id id]
+    end
+
+    def default_scope
+      model
+    end
+
+    def default_model
+      symbol_to_class(name)
+    end
+
+    def default_find(id, scope)
+      scope.find(id)
+    end
+
+    def default_build(scope)
+      scope.new
+    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 handle_custom_id(value)
+      fetch_first_defined_param value
+    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)
+      else
+        send("default_#{name}", *args)
+      end
+    end
+
+    def handle_custom_action(name, *args)
+      value = options[name]
+
+      if Proc === value
+        controller.instance_exec(*args, &value)
+      else
+        send("handle_custom_#{name}", value, *args)
+      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

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

data/spec/controller_spec.rb

@@ -0,0 +1,167 @@
+require "spec_helper"
+
+describe AdequateExposure::Controller do
+  class Thing; end
+  class DifferentThing; end
+
+  class BaseController
+    def self.helper_method(*); end
+
+    def params
+      @params ||= HashWithIndifferentAccess.new
+    end
+  end
+
+  let(:controller_klass) do
+    Class.new(BaseController) do
+      extend AdequateExposure::Controller
+    end
+  end
+
+  let(:controller){ controller_klass.new }
+
+  def expose(*args, &block)
+    controller_klass.expose(*args, &block)
+  end
+
+  context "getter/setter methods" do
+    before{ expose :thing }
+
+    it "defines getter method" do
+      expect(controller).to respond_to(:thing)
+    end
+
+    it "defines setter method" do
+      expect(controller).to respond_to(:thing=).with(1).argument
+    end
+  end
+
+  context "helper methods" do
+    it "exposes getter and setter as controller helper methods" do
+      expect(controller_klass).to receive(:helper_method).with(:thing, :thing=)
+      expose :thing
+    end
+  end
+
+  context "with block" do
+    before do
+      expose(:thing){ compute_thing }
+    end
+
+    it "executes block to calculate the value" do
+      allow(controller).to receive(:compute_thing).and_return(42)
+      expect(controller.thing).to eq(42)
+    end
+
+    it "executes the block once and memoizes the result" do
+      expect(controller).to receive(:compute_thing).once.and_return(42)
+      10.times{ controller.thing }
+    end
+
+    it "allows setting value directly" do
+      expect(controller).to_not receive(:compute_thing)
+      controller.thing = :foobar
+      expect(controller.thing).to eq(:foobar)
+    end
+  end
+
+  context "redefine fetch" do
+    before do
+      expose :thing, fetch: ->{ compute_thing }
+      allow(controller).to receive(:compute_thing).and_return(42)
+    end
+
+    it "uses provided fetch proc instead of default" do
+      expect(controller.thing).to eq(42)
+    end
+  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)
+    end
+
+    context "find" do
+      before{ expect(Thing).to receive(:find).with(10) }
+      after{ controller.thing }
+
+      it "finds Thing if thing_id param is provided" do
+        controller.params.merge! thing_id: 10
+      end
+
+      it "finds Thing if id param if provided" do
+        controller.params.merge! id: 10
+      end
+    end
+  end
+
+  context "override model" do
+    after{ expect(controller.thing).to be_instance_of(DifferentThing) }
+
+    it "allows overriding model class with proc" do
+      expose :thing, model: ->{ DifferentThing }
+    end
+
+    it "allows overriding model with class" do
+      expose :thing, model: DifferentThing
+    end
+
+    it "allows overriding model class with symbol" do
+      expose :thing, model: :different_thing
+    end
+  end
+
+  context "override scope" do
+    it "allows overriding scope with proc" do
+      scope = double("Scope")
+      expose :thing, scope: ->{ scope }
+      expect(scope).to receive(:new).and_return(42)
+      expect(controller.thing).to eq(42)
+    end
+
+    it "allows overriding with symbol" do
+      current_user = double("User")
+      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)
+    end
+  end
+
+  context "override id" do
+    after do
+      expect(Thing).to receive(:find).with(42)
+      controller.thing
+    end
+
+    it "allows overriding id with proc" do
+      expose :thing, id: ->{ get_thing_id_somehow }
+      expect(controller).to receive(:get_thing_id_somehow).and_return(42)
+    end
+
+    it "allows overriding id with symbol" do
+      expose :thing, id: :custom_thing_id
+      controller.params.merge! thing_id: 10, custom_thing_id: 42
+    end
+
+    it "allows overriding id with an array of symbols" do
+      expose :thing, id: %i[non-existent-id lolwut another_id_param]
+      controller.params.merge! another_id_param: 42
+    end
+  end
+
+  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))
+      controller.thing
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "support/rails_app"
+require "rspec/rails"
+
+describe BirdsController, type: :controller do
+  context "finds bird by id" do
+    let(:mockingbird){ double("Bird") }
+    before{ expect(Bird).to receive(:find).with("mockingbird").once.and_return(mockingbird) }
+    after{ expect(controller.bird).to eq(mockingbird) }
+
+    it "finds model by id" do
+      get :show, id: "mockingbird"
+    end
+
+    it "finds model by bird_id" do
+      get :show, bird_id: "mockingbird"
+    end
+  end
+
+  it "builds bird if id is not provided" do
+    bird = double("Bird")
+    expect(Bird).to receive(:new).and_return(bird)
+    get :show
+    expect(controller.bird).to eq(bird)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "adequate_exposure"

data/spec/support/rails_app.rb

@@ -0,0 +1,39 @@
+require "active_support/all"
+require "active_support/dependencies/autoload"
+require "action_controller"
+require "action_dispatch"
+require "rails"
+
+module Rails
+  class App
+    def env_config; {} end
+
+    def routes
+      @routes ||= ActionDispatch::Routing::RouteSet.new.tap do |routes|
+        routes.draw do
+          resource :birds
+        end
+      end
+    end
+  end
+
+  def self.application
+    @app ||= App.new
+  end
+end
+
+class Bird
+end
+
+class ApplicationConroller < ActionController::Base
+  include Rails.application.routes.url_helpers
+end
+
+class BirdsController < ApplicationConroller
+  expose :bird
+
+  def show
+    render nothing: true
+  end
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: adequate_exposure
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Pavel Pravosud
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: 
+email:
+- pavel@pravosud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- adequate_exposure.gemspec
+- lib/adequate_exposure.rb
+- lib/adequate_exposure/attribute.rb
+- lib/adequate_exposure/context.rb
+- lib/adequate_exposure/controller.rb
+- lib/adequate_exposure/exposure.rb
+- lib/adequate_exposure/flow.rb
+- lib/adequate_exposure/version.rb
+- spec/controller_spec.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+- spec/support/rails_app.rb
+homepage: https://github.com/rwz/adequate_exposure
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: More adequate than decent
+test_files:
+- spec/controller_spec.rb
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+- spec/support/rails_app.rb