xpose 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02eea2368bfae7bf652a48cf71db7f0357c8ab25
-  data.tar.gz: 0053e667c4b3ecf3dbf72018b531ac93eaff398d
+  metadata.gz: db1cd9178831f764322ecc1fcee8c71cbea41bbf
+  data.tar.gz: ef53b5687506f665152a79821410c1b6037ae6b5
 SHA512:
-  metadata.gz: ad476f2c9b6c26494c61a1ad15f2b69a35220e72e756bb699ca2051a275cb04f0f6657b2a75df0586e1c04453f94f6a271a91c781ec3f8124441d178ad1eb208
-  data.tar.gz: 715cda9831883f00b03133bf9c7655412b73ae3e43a44ca93cdadd1b64afed9e268b1358ecb7ad3b48089f69dc910aa2e50993deac29a8f78d8e72550b53d4fa
+  metadata.gz: 2d75cf01c927100f4a08c015646dd3a9e492fc3861813e94032dba6074abe78771fd12eaf475dd67bdca60e0eeaddcdc5ad05f7df9b51ae27b1e48f7f630c7b5
+  data.tar.gz: ab816dd1c4c781774413ad84c41f58297295e3bce1c7dc3e4fab085b6de2709635ea103e1e113b547fd6ebe73e19e1267b751236b195c943fb9b76e7c289df41

data/README.md

@@ -1,5 +1,11 @@
 # Xpose
 
+[![Gem Version](https://img.shields.io/gem/v/xpose.svg)](https://rubygems.org/gems/xpose)
+
+## Presentation
+
+**Xpose** provides a set of helpers that help you write smaller, cleaner controllers.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -10,7 +16,144 @@ gem 'xpose'
 
 And then execute:
 
-    $ bundle
+```shell
+bundle install
+```
+
+## Basic usage
+
+Here is a basic scaffolded controller in Rails (comments removed):
+
+```ruby
+class ArticlesController < ApplicationController
+  before_action :set_article, only: [:show, :edit, :update, :destroy]
+
+  def index
+    @articles = Article.all
+  end
+
+  def show
+  end
+
+  def new
+    @article = Article.new
+  end
+
+  def edit
+  end
+
+  def create
+    @article = Article.new(article_params)
+
+    respond_to do |format|
+      if @article.save
+        format.html { redirect_to @article, notice: 'Article was successfully created.' }
+        format.json { render :show, status: :created, location: @article }
+      else
+        format.html { render :new }
+        format.json { render json: @article.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def update
+    respond_to do |format|
+      if @article.update(article_params)
+        format.html { redirect_to @article, notice: 'Article was successfully updated.' }
+        format.json { render :show, status: :ok, location: @article }
+      else
+        format.html { render :edit }
+        format.json { render json: @article.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    @article.destroy
+    respond_to do |format|
+      format.html { redirect_to articles_url, notice: 'Article was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    def set_article
+      @article = Article.find(params[:id])
+    end
+
+    def article_params
+      params.require(:article).permit(:name, :content)
+    end
+end
+```
+
+Here is the Xpose-friendly equivalent:
+
+```ruby
+class ArticlesController < ApplicationController
+  expose :articles
+  expose :article
+
+  def index
+  end
+
+  def show
+  end
+
+  def new
+  end
+
+  def create
+    if article.save
+      redirect_to article, notice: 'Article was successfully created.'
+    else
+      render :new
+    end
+  end
+
+  def edit
+  end
+
+  def update
+    if article.update(article_params)
+      redirect_to article, notice: 'Article was successfully updated.'
+    else
+      render :edit
+    end
+  end
+
+  def destroy
+    article.destroy
+    redirect_to articles_url, notice: 'Article was successfully destroyed.'
+  end
+
+  private
+
+  def article_params
+    params.require(:article).permit(:name)
+  end
+end
+```
+
+## Helpers
+
+### expose
+
+`expose` provides powerful tools to help you minimize your controllers.
+
+Default values:
+`expose :name, :infer, scope: :all, decorate: true, decorator: :infer`
+
+Examples:
+
+```ruby
+expose :articles
+expose :articles, scope: :visible
+expose :article
+expose :forthy_two, 42, decorate: false
+expose :bob, "Bob", decorator: -> { |v| v.length }
+
+```
 
 ## Usage
 

data/lib/xpose.rb

@@ -2,7 +2,8 @@ require "xpose/version"
 require "active_support/all"
 
 module Xpose
-  class MissingParameterError < StandardError ; end
+  class UnknownOptionsError < StandardError ; end
+  class MissingOptionError < StandardError ; end
   class UnknownDecoratorError < StandardError ; end
 
   autoload :Configuration, 'xpose/configuration.rb'

data/lib/xpose/configuration.rb

@@ -1,29 +1,48 @@
 module Xpose
-  module Configuration
+  class Configuration
+
     DEFAULT_VALUES = {
       name: nil,
       value: nil,
       decorate: true,
       decorator: :infer,
-      infer_value: true,
       scope: :all
+      # source: :infer (:infer, :method, : .call : ...)
     }.freeze
 
-    def self.build(**args)
-      args = DEFAULT_VALUES.merge(args).keep_if do |k, v|
-        DEFAULT_VALUES.has_key?(k)
+    def initialize(**options)
+      @options = options
+      permit_options! unless options.fetch(:permissive, false)
+      build_config
+      build_internal_defaults
+    end
+
+    def method_missing(method, *args, &block)
+      config.send(method, *args, &block)
+    end
+
+    def model
+      config.singularized_name.capitalize.constantize
+    end
+
+    private
+
+    attr_accessor :config
+
+    def permit_options!
+      (@options.keys - DEFAULT_VALUES.keys).tap do |unknown_keys|
+        raise UnknownOptionsError.new(unknown_keys) unless unknown_keys.empty?
       end
-      OpenStruct.new(args).tap do |conf|
-        conf.name = conf.name.to_s
-        conf.method_name = conf.name.to_sym
-        conf.instance_variable_name = :"@#{conf.method_name}"
+    end
 
-        conf.singularized_name = conf.name.singularize
-        conf.pluralized_name = conf.name.pluralize
+    def build_config
+      @config = OpenStruct.new(DEFAULT_VALUES.merge(@options)).tap do |c|
+        raise MissingOptionsError.new(:name) if c.name.blank?
 
-        conf.decorated_name = "decorated_#{conf.name}"
-        conf.decorated_method_name = conf.decorated_name.to_sym
-        conf.decorated_instance_variable_name = :"@decorated_#{conf.method_name}"
+        c.name = c.name.to_sym
+        c.ivar_name = :"@#{c.name}"
+        c.singularized_name = c.name.to_s.singularize
+        c.pluralized_name = c.singularized_name.pluralize
       end
     end
   end

data/lib/xpose/controller.rb

@@ -5,36 +5,31 @@ module Xpose
     module ClassMethods
       def _expose(**args)
         ::Xpose::Exposed.new(args).tap do |inst|
-          define_method inst.conf.method_name do
-            if instance_variable_defined?(inst.conf.instance_variable_name)
-              instance_variable_get(inst.conf.instance_variable_name)
+          @@exposed ||= {}
+          @@exposed[inst.conf.name] = inst
+          define_method inst.conf.name do
+            if instance_variable_defined?(inst.conf.ivar_name)
+              instance_variable_get(inst.conf.ivar_name)
             else
-              instance_variable_set(inst.conf.instance_variable_name, inst.call(self))
+              instance_variable_set(inst.conf.ivar_name, inst.exposed_value(self))
             end
           end
-          helper_method(inst.conf.method_name)
-          self._decorate(args) if inst.conf[:decorate]
+          helper_method(inst.conf.name)
         end
       end
 
-      def expose(name, value = nil, **args, &block)
+      def expose(names, value = nil, **args, &block)
         value = value || args.fetch(:value, nil) || block
-        _expose({ name: name, value: value }.merge(args))
+        [names].flatten.each { |name| _expose({ name: name, value: value }.merge(args)) }
       end
 
-      def expose!(name, value = nil, **args, &block)
+      def expose!(names, value = nil, **args, &block)
         expose(name, value, args, &block)
-        before_action(name)
+        [names].flatten.each { |name| before_action(name) }
       end
 
-      def _decorate(**args)
-        ::Xpose::Decorated.new(args).tap do |inst|
-          _expose({ name: inst.conf.decorated_name, value: -> { inst.call(self) }, decorate: false })
-        end
-      end
-
-      def decorate(name, **args, &block)
-        _decorate({ name: name }.merge(args))
+      def exposed
+        @@exposed ||= {}
       end
     end
   end

data/lib/xpose/decorated.rb

@@ -1,52 +1,54 @@
 module Xpose
   class Decorated
-    attr_accessor :conf
+    attr_reader :conf
 
-    def initialize(**args)
-      @conf = ::Xpose::Configuration.build(args)
-      raise MissingParameter if conf.name.nil?
-      decorate_self if conf.decorate == :self
+    def initialize(**options)
+      @conf = ::Xpose::Configuration.new(options.merge(permissive: true))
     end
 
-    def call(instance)
-      v = instance.send(conf.method_name)
+    def value(instance, v)
+      return v unless shall_decorate?(instance, v)
       if conf.decorator == :infer
         infer(v)
       elsif Class === conf.decorator
-        decorator.new(v)
-      elsif decorator.respond_to?(:call)
-        decorator.call(v)
-      elsif Symbol === decorator
-        decorator.to_s.singularize.capitalize.constantize.new(v)
+        conf.decorator.new(v)
+      elsif conf.decorator.respond_to?(:call)
+        conf.decorator.call(v)
+      elsif Symbol === conf.decorator && class_exists?(klass_from_symbol)
+        klass_from_symbol.new(v)
       else
-        raise StandardError.new('Unknown decorator')
+        raise UnknownDecoratorError.new(conf.decorator)
       end
     end
 
     private
 
-    def decorate_self
-      conf.decorated_name = conf.name
-      conf.decorated_method_name = conf.method_name
-      conf.decorated_instance_variable_name = conf.instance_variable_name
+    def shall_decorate?(instance, v)
+      return conf.decorate if [true, false].include?(conf.decorate)
+      raise UnknownOptionsError.new(:decorate) unless conf.decorate.respond_to?(:call)
+      instance.instance_exec &conf.decorate
     end
 
     def infer(v)
       if v.respond_to?(:decorate)
         v.decorate
-      elsif class_exists?(klass)
-        klass.new(v)
+      elsif class_exists?(klass_from_model)
+        klass_from_model.new(v)
       else
-        raise UnknownDecoratorError
+        raise UnknownDecoratorError.new(conf.decorator)
       end
     end
 
-    def klass
-      @klass ||= "#{conf.singularized_name.capitalize}Decorator".constantize
+    def klass_from_symbol
+      conf.decorator.to_s.singularize.capitalize.constantize
+    end
+
+    def klass_from_model
+      "#{conf.model}Decorator".constantize
     end
 
     def class_exists?(class_name)
-      Module.const_get(class_name).is_a?(Class)
+      Module.const_get(class_name.to_s).is_a?(Class)
     rescue NameError
       return false
     end

data/lib/xpose/exposed.rb

@@ -3,62 +3,61 @@ module Xpose
     attr_accessor :conf
 
     def initialize(**args)
-      @conf = ::Xpose::Configuration.build(args)
-      conf.name.tap do |name|
-        raise MissingParameterError if name.nil?
-      end
+      @conf = ::Xpose::Configuration.new(args)
+    end
+
+    def value(instance)
+      @instance = instance
+      @value ||= interpret_value
     end
 
-    def call(instance)
+    def decorated_value(instance)
       @instance = instance
-      v = if conf.value.nil? && conf.infer_value
-            (conf.method_name.to_s == conf.pluralized_name ? :collection : :record)
-          else
-            conf.value
-          end
-      reinterpret_value(v)
+      @decorated_value ||=
+        if value(instance) && conf.decorate
+          ::Xpose::Decorated.new(conf.to_h).value(instance, value(instance))
+        else
+          nil
+        end
+    end
+
+    def exposed_value(instance)
+      decorated_value(instance) || value(instance)
     end
 
     private
 
     attr_reader :instance
 
-    def class_exists?(class_name)
-      Module.const_get(class_name).is_a?(Class)
-    rescue NameError
-      return false
+    def interpret_value
+      if conf.value.respond_to?(:call)
+        instance.instance_exec &conf.value
+      else
+        infer_value
+      end
     end
 
-    def klass
-      @klass ||= conf.singularized_name.capitalize.constantize
+    def infer_value
+      conf.value == :collection ? infer_collection : infer_record
     end
 
-    def reinterpret_value(v)
-      if v.respond_to?(:call)
-        instance.instance_exec &v
-      elsif v == :collection
-        infer_collection
-      elsif v == :record
-        infer_record
-      else
-        v
-      end
+    def infer_collection
+      conf.model.send(conf.scope)
     end
 
-    def infer_collection
-      klass.send(conf.scope)
+    def record_source
+      if instance.respond_to?(conf.pluralized_name)
+        instance.class.exposed[conf.pluralized_name.to_sym].value(instance)
+      else
+        conf.model.send(conf.scope)
+      end
     end
 
     def infer_record
-      source = if instance.respond_to?(conf.pluralized_name)
-                 ->{ instance.send(conf.pluralized_name) }
-               else
-                 ->{ klass.send(conf.scope) }
-               end
-      if instance.respond_to?(:params) && instance.params.has_key?(:id)
-        source.call.find(instance.params[:id])
+      if instance.respond_to?(:params, true) && instance.params.has_key?(:id)
+        record_source.find(instance.params[:id])
       else
-        source.call.new(params)
+        record_source.new(params)
       end
     end
 
@@ -72,5 +71,11 @@ module Xpose
       end
       {}
     end
+
+    def class_exists?(class_name)
+      Module.const_get(class_name).is_a?(Class)
+    rescue NameError
+      return false
+    end
   end
 end

data/lib/xpose/version.rb

@@ -1,3 +1,3 @@
 module Xpose
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xpose
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Younes SERRAJ
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-14 00:00:00.000000000 Z
+date: 2018-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler