grape_has_scope 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5781a062b32b540e375568c51c45fe38c92729df
+  data.tar.gz: 4e02b3a418cd8d02d5a7417071eef84bb94af337
+SHA512:
+  metadata.gz: 4529bd0a950ce35b9e3087fa84f76674384c17d620bc708c7669478149a4a955381944f5bb347cfce821499ea77af6e661bf0cbff819434c6ea3e7361effc74d
+  data.tar.gz: f0b49285d0bbb10daae6eef30689519572bd124d2b1ceee6f014708d9b18417bf92ab0160e6f0eae16caf92469d66d597ceb21340e5d836fe8de4b21a93fac83

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Declare your gem's dependencies in dalli-delete-matched.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# jquery-rails is used by the dummy application
+# gem "jquery-rails"
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/Gemfile.lock

@@ -0,0 +1,14 @@
+PATH
+  remote: .
+  specs:
+    grape_has_scope (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  grape_has_scope!

data/README.rdoc

@@ -0,0 +1,3 @@
+= has_scope implementation to use with Grape API
+
+In a hurry, will write the instructions later :))

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/grape_has_scope.rb

@@ -0,0 +1,150 @@
+module GrapeHasScope
+  TRUE_VALUES = ["true", true, "1", 1]
+
+  ALLOWED_TYPES = {
+    :array   => [ Array ],
+    :hash    => [ Hash ],
+    :boolean => [ Object ],
+    :default => [ String, Numeric ]
+  }
+
+  def self.included(base)
+    base.class_eval do
+      class_attribute :scopes_configuration
+    end
+  end
+
+  def has_scope(*scopes, &block)
+    options = scopes.extract_options!
+    options.symbolize_keys!
+    options.assert_valid_keys(:type, :only, :except, :if, :unless, :default, :as, :using, :allow_blank)
+
+    if options.key?(:using)
+      if options.key?(:type) && options[:type] != :hash
+        raise "You cannot use :using with another :type different than :hash"
+      else
+        options[:type] = :hash
+      end
+
+      options[:using] = Array(options[:using])
+    end
+
+    options[:only]   = Array(options[:only])
+    options[:except] = Array(options[:except])
+
+    self.class.scopes_configuration = (self.class.scopes_configuration || {}).dup
+
+    scopes.each do |scope|
+      self.class.scopes_configuration[scope] ||= { :as => scope, :type => :default, :block => block }
+      self.class.scopes_configuration[scope] = self.class.scopes_configuration[scope].merge(options)
+    end
+  end
+
+  # Receives an object where scopes will be applied to.
+  #
+  #   class GraduationsController < InheritedResources::Base
+  #     has_scope :featured, :type => true, :only => :index
+  #     has_scope :by_degree, :only => :index
+  #
+  #     def index
+  #       @graduations = apply_scopes(Graduation).all
+  #     end
+  #   end
+  #
+  def apply_scopes(target, hash=params)
+    return target unless scopes_configuration
+
+    self.class.scopes_configuration.each do |scope, options|
+      next unless apply_scope_to_action?(options)
+      key = options[:as]
+
+      if hash.key?(key)
+        value, call_scope = hash[key], true
+      elsif options.key?(:default)
+        value, call_scope = options[:default], true
+        value = value.call(self) if value.is_a?(Proc)
+      end
+
+      value = parse_value(options[:type], key, value)
+      value = normalize_blanks(value)
+
+      if call_scope && (value.present? || options[:allow_blank])
+        current_scopes[key] = value
+        target = call_scope_by_type(options[:type], scope, target, value, options)
+      end
+    end
+
+    target
+  end
+
+  # Set the real value for the current scope if type check.
+  def parse_value(type, key, value) #:nodoc:
+    if type == :boolean
+      TRUE_VALUES.include?(value)
+    elsif value && ALLOWED_TYPES[type].any?{ |klass| value.is_a?(klass) }
+      value
+    end
+  end
+
+  # Screens pseudo-blank params.
+  def normalize_blanks(value) #:nodoc:
+    return value if value.nil?
+    if value.is_a?(Array)
+      value.select { |v| v.present? }
+    elsif value.is_a?(Hash)
+      value.select { |k, v| normalize_blanks(v).present? }.with_indifferent_access
+    else
+      value
+    end
+  end
+
+  # Call the scope taking into account its type.
+  def call_scope_by_type(type, scope, target, value, options) #:nodoc:
+    block = options[:block]
+
+    if type == :boolean
+      block ? block.call(self, target) : target.send(scope)
+    elsif value && options.key?(:using)
+      value = value.values_at(*options[:using])
+      block ? block.call(self, target, value) : target.send(scope, *value)
+    else
+      block ? block.call(self, target, value) : target.send(scope, value)
+    end
+  end
+
+  # Given an options with :only and :except arrays, check if the scope
+  # can be performed in the current action.
+  def apply_scope_to_action?(options) #:nodoc:
+    return false unless applicable?(options[:if], true) && applicable?(options[:unless], false)
+
+    if options[:only].empty?
+      options[:except].empty? || !options[:except].include?(action_name.to_sym)
+    else
+      options[:only].include?(action_name.to_sym)
+    end
+  end
+
+  # Evaluates the scope options :if or :unless. Returns true if the proc
+  # method, or string evals to the expected value.
+  def applicable?(string_proc_or_symbol, expected) #:nodoc:
+    case string_proc_or_symbol
+      when String
+        eval(string_proc_or_symbol) == expected
+      when Proc
+        string_proc_or_symbol.call(self) == expected
+      when Symbol
+        send(string_proc_or_symbol) == expected
+      else
+        true
+    end
+  end
+
+  # Returns the scopes used in this action.
+  def current_scopes
+    @current_scopes ||= {}
+  end
+end
+
+class Grape::Endpoint
+  include GrapeHasScope
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: grape_has_scope
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kourza Ivan a.k.a. Phobos98
+autorequire: builder
+bindir: bin
+cert_chain: []
+date: 2014-01-09 00:00:00.000000000 Z
+dependencies: []
+description: has_scope implementation to use with Grape API
+email: phobos98@phobos98.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- Gemfile
+- Rakefile
+- README.rdoc
+- Gemfile.lock
+files:
+- lib/grape_has_scope.rb
+- Gemfile
+- Rakefile
+- README.rdoc
+- Gemfile.lock
+homepage: https://github.com/Phobos98/grape_has_scope.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: grape_has_scope
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: has_scope implementation to use with Grape API
+test_files: []
+has_rdoc: true