stately_scopes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 003e838787afee6e32b00bc0b1de8793f1e652b0
+  data.tar.gz: ec12b2749a9249961e1e7addf8fcfdf928f49ed3
+SHA512:
+  metadata.gz: b644ea250dbb4a31678126f699ef27b9de1e23dfcb898ed7a8072586957af7389d9995d64a6d775ad5b958c27113d9521d91bcfcad20e86d14d94e6b0956220b
+  data.tar.gz: 245a8e943b2466e9783622bfbacf76135f6696a7193e3b38a3cce74c7161ee485b7d3b64f2e349256b1736a2495fb87bffa32c1278d3b91cac338bb8decc23b2

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+
+gemfile:
+  - Gemfile

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record-scoping-with_state.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nicholas Bruning
+
+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,124 @@
+# StatelyScopes
+
+[![Build Status](https://travis-ci.org/thetron/stately_scopes.svg?branch=master)](https://travis-ci.org/thetron/stately_scopes)
+[![Code Climate](https://codeclimate.com/github/thetron/stately_scopes.png)](https://codeclimate.com/github/thetron/stately_scopes)
+
+An ActiveRecord extension so small, it's almost silly - but it is kinda helpful.
+
+I've found that when developing Rails apps, I tend to almost always pair each
+scope with an instance method which returns a boolean indicating whether the
+object is included inside a given scope.
+
+This gem simply automates that method creation for you. Nothing super fancy,
+and you might consider replacing the state methods with your own, more
+efficient, implementations - but it's great for early stages of development, or
+providing a comparative case for unit tests.
+
+
+## Example
+
+Using a small `Event` model:
+
+```ruby
+class Event < ActiveRecord::Base
+  include StatelyScopes
+  scope :upcoming, -> { where ("starts_at > ?", Time.now) }
+end
+```
+
+```ruby
+old_event = Event.create(:starts_at => 1.day.ago)
+upcoming_event = Event.create(:starts_at => 1.day.from_now)
+
+old_event.upcoming? # => false
+upcoming_event.upcoming? # => true
+```
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'stately_scopes'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem 'stately_scopes'
+
+
+## Usage
+
+The gem automatically aliases the existing `scope` method provided by
+ActiveRecord, so all of your models will have the new state methods by default.
+
+The helper methods will have the same name as your scopes, with a `?` appended.
+
+Eg:
+
+`scope :upcoming, -> { ... }` will generate `.upcoming?`  
+and  
+`scope :spam -> { ... }` will generate `.spam?`
+
+You get the picture.
+
+If you're wanting to avoid the automatically generated state methods on a given
+scope, you can simply use `scope_without_state` instead of `scope`.
+
+
+## Configuration
+
+You can turn off the automatic aliasing of `scope`, and explicitly call
+`scope_with_state` instead, for each scope that you'd like to have generated
+state method for. To do that, add the following initializer:
+
+```ruby
+# config/initializers/active_record-scoping-with_state.rb
+StatelyScopes.configure do |config|
+  config.alias_scope_method = false
+end
+```
+
+
+## Caveats
+
+It should be noted that the instance methods do use a database query in order
+to establish a model instance's state. Arguably not ideal, however the query is
+as efficient as possible (I think?).
+
+If you have performance concerns, I would recommend overriding the generated
+state methods for production use. In this case, this gem can still be used
+in test cases by calling `.has_scoped_state(scope_name)` on your model instances.
+In this way, you can help validate that your overridden state methods are
+congruent to the conditions in your scope.
+
+Using the above `Event` model again, however the `upcoming?` method has been
+overridden with:
+
+```ruby
+# app/models/event.rb
+
+def upcoming?
+  self.starts_at > Time.now
+end
+```
+
+Obviously this is better than hitting the database, however we'd like to write
+a test case that ensures that the new method is the equivalent of the generated
+one - so we can do something like this:
+
+```ruby
+future_event = Event.create(:starts_at => 5.days.from_now)
+assert_equal future_event.upcoming?, future_event.has_scoped_state?(:upcoming)
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/thetron/active_record-scoping-with_state/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 new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.libs.push 'spec'
+end
+
+task :default => [:test]

data/lib/stately_scopes/version.rb

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

data/lib/stately_scopes.rb

@@ -0,0 +1,45 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/aliasing'
+
+module StatelyScopes
+  extend ActiveSupport::Concern
+
+  included do
+    class_eval do
+      class << self
+        alias_method_chain :scope, :state if StatelyScopes.configuration.alias_scope_method
+      end
+    end
+  end
+
+  def has_scoped_state?(name)
+    self.class.send(name.to_sym).exists?(self.id)
+  end
+
+  module ClassMethods
+    def scope_with_state(name, body, &block)
+      if StatelyScopes.configuration.alias_scope_method
+        scope_without_state name, body, &block
+      else
+        scope name, body, &block
+      end
+      class_eval "def #{name}?() self.has_scoped_state?(#{name}) end"
+    end
+  end
+
+  class << self
+    def configure(&block)
+      yield(StatelyScopes::Configuration.configuration)
+    end
+
+    def configuration
+      StatelyScopes::Configuration.configuration
+    end
+  end
+
+  class Configuration
+    def self.configuration
+      @@configuration ||= OpenStruct.new(:alias_scope_method => true)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'bundler'
+Bundler.require(:default)
+
+require 'active_record'
+require 'stately_scopes'
+require 'pp'
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/mock'
+require 'minitest/pride'
+
+module MiniTest
+  class Spec
+    class << self
+      alias_method :context, :describe
+    end
+  end
+end
+
+
+#ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+ActiveRecord::Schema.define do
+  create_table :widgets do |table|
+    table.column :fake, :boolean
+  end
+end
+
+def reload_widget
+  Object.send(:remove_const, :Widget)
+  load 'support/widget.rb'
+end
+
+load 'support/widget.rb'

data/spec/stately_scopes_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe StatelyScopes do
+  it "aliases the scope method" do
+    Widget.public_methods.must_include :scope_without_state, "Expected widget to alias `scope'"
+  end
+
+  describe ".has_scoped_state?" do
+    context "when object is in the scope" do
+      it "returns true" do
+        widget = Widget.create(:fake => true)
+        widget.has_scoped_state?(:faked).must_equal true
+      end
+    end
+
+    context "when object is outside the scope" do
+      it "returns false" do
+        widget = Widget.create(:fake => false)
+        widget.has_scoped_state?(:faked).must_equal false
+      end
+    end
+  end
+
+  describe "#scope_with_state" do
+    it "defines a scope" do
+      Widget.public_methods.must_include :faked
+    end
+
+    it "defines a state instance method" do
+      Widget.new.public_methods.must_include :faked?
+    end
+  end
+
+  describe "configuration" do
+    context "when alias_scope_method = false" do
+      it "does not alias the scope method" do
+        StatelyScopes.configure { |c| c.alias_scope_method = false }
+        reload_widget
+        Widget.public_methods.wont_include :scope_without_state, "Expected widget to not alias `scope'"
+      end
+    end
+
+    describe "#configure" do
+      it "yields the configuration" do
+        StatelyScopes.configure do |config|
+          config.must_equal StatelyScopes::Configuration.configuration
+        end
+      end
+    end
+
+    describe "#configuration" do
+      it "sets alias_scope_method to true by default" do
+        StatelyScopes.configuration.alias_scope_method.must_equal true
+      end
+    end
+  end
+end

data/spec/support/widget.rb

@@ -0,0 +1,4 @@
+class Widget < ActiveRecord::Base
+  include StatelyScopes
+  scope :faked, -> { where(:fake => true) }
+end

data/stately_scopes.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stately_scopes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stately_scopes"
+  spec.version       = StatelyScopes::VERSION
+  spec.authors       = ["Nicholas Bruning"]
+  spec.email         = ["nicholas@bruning.com.au"]
+  spec.summary       = %q{Automatically creates state query methods for each of your model's scopes.}
+  spec.description   = %q{I've found that when developing Rails apps, I tend to almost always pair each scope with an instance method which returns a boolean indicating whether the object is included inside that scope.\n\nThis gem simply automatically creates that method for you. Nothing super fancy, and you might consider replacing the state methods with your own, more efficient, implementations - but it's great for early stages of development, or providing a comparative case for unit tests.}
+  spec.homepage      = "http://github.com/thetron/stately_scopes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activerecord",   "~> 4.0.4"
+
+  spec.add_development_dependency "bundler",    "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "sqlite3"
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: stately_scopes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nicholas Bruning
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: I've found that when developing Rails apps, I tend to almost always pair
+  each scope with an instance method which returns a boolean indicating whether the
+  object is included inside that scope.\n\nThis gem simply automatically creates that
+  method for you. Nothing super fancy, and you might consider replacing the state
+  methods with your own, more efficient, implementations - but it's great for early
+  stages of development, or providing a comparative case for unit tests.
+email:
+- nicholas@bruning.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/stately_scopes.rb
+- lib/stately_scopes/version.rb
+- spec/spec_helper.rb
+- spec/stately_scopes_spec.rb
+- spec/support/widget.rb
+- stately_scopes.gemspec
+homepage: http://github.com/thetron/stately_scopes
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Automatically creates state query methods for each of your model's scopes.
+test_files:
+- spec/spec_helper.rb
+- spec/stately_scopes_spec.rb
+- spec/support/widget.rb