stretchy-model 0.6.5 → 0.6.6

data/lib/stretchy/persistence.rb

@@ -1,43 +0,0 @@
-module Stretchy
-    module Persistence
-        extend ActiveSupport::Concern
-
-        class_methods do
-            def create(*args)
-                self.new(*args).save
-            end
-        end
-
-        def save
-            run_callbacks :save do
-                if new_record?
-                    run_callbacks :create do
-                        response = self.class.gateway.save(self.attributes)
-                        self.id = response['_id']
-                    end
-                else
-                    self.class.gateway.save(self.attributes)
-                end
-                self
-            end
-        end
-
-        def destroy
-            run_callbacks :destroy do
-                delete
-            end
-        end
-
-        def delete
-            self.class.gateway.delete(self.id)["result"] == 'deleted'
-        end
-
-        def update(*args)
-            run_callbacks :update do
-                self.assign_attributes(*args)
-                self.save
-            end
-        end
-
-    end
-end

data/lib/stretchy/refreshable.rb

@@ -1,15 +0,0 @@
-module Stretchy
-  module Refreshable
-    extend ActiveSupport::Concern
-
-    included do
-      after_save :refresh_index
-      after_destroy :refresh_index
-    end
-
-    def refresh_index
-      self.class.refresh_index!
-    end
-
-  end
-end

data/lib/stretchy/scoping/default.rb

@@ -1,134 +0,0 @@
-module Stretchy
-  module Scoping
-    module Default
-      extend ActiveSupport::Concern
-
-      included do
-        # Stores the default scope for the class.
-        class_attribute :default_scopes, instance_writer: false, instance_predicate: false
-
-        self.default_scopes = []
-      end
-
-      module ClassMethods
-        # Returns a scope for the model without the previously set scopes.
-        #
-        #   class Post < ActiveRecord::Base
-        #     def self.default_scope
-        #       where published: true
-        #     end
-        #   end
-        #
-        #   Post.all                                  # Fires "SELECT * FROM posts WHERE published = true"
-        #   Post.unscoped.all                         # Fires "SELECT * FROM posts"
-        #   Post.where(published: false).unscoped.all # Fires "SELECT * FROM posts"
-        #
-        # This method also accepts a block. All queries inside the block will
-        # not use the previously set scopes.
-        #
-        #   Post.unscoped {
-        #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
-        #   }
-        def unscoped
-          block_given? ? relation.scoping { yield } : relation
-        end
-
-        def before_remove_const #:nodoc:
-          self.current_scope = nil
-        end
-
-        protected
-
-        # Use this macro in your model to set a default scope for all operations on
-        # the model.
-        #
-        #   class Article < ActiveRecord::Base
-        #     default_scope { where(published: true) }
-        #   end
-        #
-        #   Article.all # => SELECT * FROM articles WHERE published = true
-        #
-        # The +default_scope+ is also applied while creating/building a record.
-        # It is not applied while updating a record.
-        #
-        #   Article.new.published    # => true
-        #   Article.create.published # => true
-        #
-        # (You can also pass any object which responds to +call+ to the
-        # +default_scope+ macro, and it will be called when building the
-        # default scope.)
-        #
-        # If you use multiple +default_scope+ declarations in your model then
-        # they will be merged together:
-        #
-        #   class Article < ActiveRecord::Base
-        #     default_scope { where(published: true) }
-        #     default_scope { where(rating: 'G') }
-        #   end
-        #
-        #   Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G'
-        #
-        # This is also the case with inheritance and module includes where the
-        # parent or module defines a +default_scope+ and the child or including
-        # class defines a second one.
-        #
-        # If you need to do more complex things with a default scope, you can
-        # alternatively define it as a class method:
-        #
-        #   class Article < ActiveRecord::Base
-        #     def self.default_scope
-        #       # Should return a scope, you can call 'super' here etc.
-        #     end
-        #   end
-        def default_scope(scope = nil)
-          scope = Proc.new if block_given?
-
-          if scope.is_a?(Relation) || !scope.respond_to?(:call)
-            raise ArgumentError,
-              "Support for calling #default_scope without a block is removed. For example instead " \
-              "of `default_scope where(color: 'red')`, please use " \
-              "`default_scope { where(color: 'red') }`. (Alternatively you can just redefine " \
-              "self.default_scope.)"
-          end
-
-          self.default_scopes += [scope]
-        end
-
-        def build_default_scope(base_rel = relation) # :nodoc:
-          if !self.is_a?(method(:default_scope).owner)
-            # The user has defined their own default scope method, so call that
-            evaluate_default_scope { default_scope }
-          elsif default_scopes.any?
-            evaluate_default_scope do
-              default_scopes.inject(base_rel) do |default_scope, scope|
-                default_scope.merge(base_rel.scoping { scope.call })
-              end
-            end
-          end
-        end
-
-        def ignore_default_scope? # :nodoc:
-          ScopeRegistry.value_for(:ignore_default_scope, self)
-        end
-
-        def ignore_default_scope=(ignore) # :nodoc:
-          ScopeRegistry.set_value_for(:ignore_default_scope, self, ignore)
-        end
-
-        # The ignore_default_scope flag is used to prevent an infinite recursion
-        # situation where a default scope references a scope which has a default
-        # scope which references a scope...
-        def evaluate_default_scope # :nodoc:
-          return if ignore_default_scope?
-
-          begin
-            self.ignore_default_scope = true
-            yield
-          ensure
-            self.ignore_default_scope = false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stretchy/scoping/named.rb

@@ -1,68 +0,0 @@
-module Stretchy
-  module Scoping
-    module Named
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def all(options={})
-          if current_scope
-            current_scope.clone
-          else
-            default_scoped
-          end
-        end
-
-        def default_scoped # :nodoc:
-          relation.merge(build_default_scope)
-        end
-
-        # Collects attributes from scopes that should be applied when creating
-        # an AR instance for the particular class this is called on.
-        def scope_attributes # :nodoc:
-          all.scope_for_create
-        end
-
-        # Are there default attributes associated with this scope?
-        def scope_attributes? # :nodoc:
-          current_scope || default_scopes.any?
-        end
-
-        def scope(name, body, &block)
-          if dangerous_class_method?(name)
-            raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
-              "on the model \"#{self.name}\", but there's already defined " \
-              "a class method with the same name."
-          end
-
-          extension = Module.new(&block) if block
-
-          singleton_class.send(:define_method, name) do |*args|
-            scope = all.scoping { body.call(*args) }
-            scope = scope.extending(extension) if extension
-
-            scope || all
-          end
-        end
-
-        BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
-
-        private
-        def dangerous_class_method?(method_name)
-          BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Model, self.superclass)
-        end
-
-        def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc
-          if klass.respond_to?(name, true)
-            if superklass.respond_to?(name, true)
-              klass.method(name).owner != superklass.method(name).owner
-            else
-              true
-            end
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stretchy/scoping/scope_registry.rb

@@ -1,34 +0,0 @@
-module Stretchy
-    module Scoping
-        class ScopeRegistry # :nodoc:
-            # extend ActiveSupport::PerThreadRegistry
-            thread_mattr_accessor :registry
-
-            VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
-
-            # def initialize
-                self.registry = Hash.new { |hash, key| hash[key] = {} }
-            # end
-
-            # Obtains the value for a given +scope_name+ and +variable_name+.
-            def self.value_for(scope_type, variable_name)
-                raise_invalid_scope_type!(scope_type)
-                self.registry[scope_type][variable_name]
-            end
-
-            # Sets the +value+ for a given +scope_type+ and +variable_name+.
-            def self.set_value_for(scope_type, variable_name, value)
-                raise_invalid_scope_type!(scope_type)
-                self.registry[scope_type][variable_name] = value
-            end
-
-            private
-
-            def raise_invalid_scope_type!(scope_type)
-                if !VALID_SCOPE_TYPES.include?(scope_type)
-                    raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
-                end
-            end
-        end
-    end
-end

data/lib/stretchy/scoping.rb

@@ -1,28 +0,0 @@
-module Stretchy
-  module Scoping
-    extend ActiveSupport::Concern
-
-    included do
-      include Default
-      include Named
-    end
-
-    module ClassMethods
-      def base_class
-        self
-      end
-
-      def current_scope
-          ScopeRegistry.new.registry[:current_scope][base_class.to_s]
-          # ScopeRegistry.value_for(:current_scope, base_class.to_s)
-      end
-
-      def current_scope=(scope) #:nodoc:
-        ScopeRegistry.new.registry[:current_scope][base_class.to_s] = scope
-        # ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
-      end
-    end
-
-
-  end
-end