scopify 0.1.0

data/README.md

@@ -0,0 +1,56 @@
+Add named scopes and chainable scopes to any Object / Model.
+
+ - As gem: ` sudo gem install scopify `
+ - As Rails plugin: ` rails plugin install git://github.com/grosser/scopify.git `
+
+Usage
+=====
+
+### scoped
+Create a scope on the fly.
+    MyDBWrapper.scoped(:limit => 10).scoped(:order => "something").all(:offset => 1)
+    --> MyDBWrapper.all receives: {:limit => 10, :order => "something", :offset => 1}
+
+### scope
+Create named scopes, with options, lambdas or other scopes
+    class MyDBWrapper
+      include Scopify
+      scope :good, :conditions => {:good => true}
+      scope :okay, good.scoped(:conditions => {:goodness => [1,2,3]}
+      scope :goodness, lambda{|factor| {:conditions => {:goodness => factor}} }
+    end
+
+    MyDBWrapper.good.first
+    MyDBWrapper.good.goodness(3).first
+
+### scope_to_hash
+Roll your own condition composing.
+    # not good ?
+    MyDBWrapper.scoped(:order => 'a').scoped(:order => 'b).all --> {:order => "a, b"}
+
+    # roll your own !
+    class MyDBWrapper
+      def self.scope_to_hash(options)
+        options.map do |key, values|
+          value = case key
+          when :limit, :offset then values.min
+          when :order then values.join(' AND ')
+          else values.join(', ')
+          end
+          [key, value]
+        end
+      end
+    end
+
+    # better now !
+    MyDBWrapper.scoped(:order => 'a').scoped(:order => 'b).all --> {:order => "a AND b"}
+
+### first
+When calling first on and scope, `:limit => 1` will be added
+    MyDBWrapper.scoped(:limit => 1).all == MyDBWrapper.first
+
+Author
+======
+[Michael Grosser](http://pragmatig.wordpress.com)  
+grosser.michael@gmail.com  
+Hereby placed under public domain, do what you want, just do not hold me accountable...

data/Rakefile

@@ -0,0 +1,20 @@
+task :default => :spec
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new {|t| t.spec_opts = ['--color']}
+
+begin
+  require 'jeweler'
+  project_name = 'scopify'
+
+  Jeweler::Tasks.new do |gem|
+    gem.name = project_name
+    gem.summary = "Add named scopes and scoped to any Object / Model."
+    gem.email = "grosser.michael@gmail.com"
+    gem.homepage = "http://github.com/grosser/#{project_name}"
+    gem.authors = ["Michael Grosser"]
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/init.rb

@@ -0,0 +1 @@
+require 'scopify'

data/lib/scopify.rb

@@ -0,0 +1,36 @@
+require 'scopify/scope'
+
+module Scopify
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+  end
+
+  module ClassMethods
+    def scoped(options)
+      Scope.build(self, options)
+    end
+
+    def scope(name, options)
+      # give access to current options inside of evaled method
+      meta_class = (class << self; self; end)
+      meta_class.send(:define_method, "#{name}_scope_options") do
+        options
+      end
+
+      class_eval <<-CODE
+        def self.#{name}(*args)
+          options = #{name}_scope_options
+          if options.is_a?(Proc)
+            scoped(options.call(*args))
+          elsif options.is_a?(Scope)
+            options
+          else
+            scoped(options)      
+          end
+        end
+      CODE
+    end
+  end
+end

data/lib/scopify/scope.rb

@@ -0,0 +1,74 @@
+module Scopify
+  class Scope
+    def initialize(base, options)
+      @base = base
+      @options = options
+    end
+
+    def scope_options
+      @options
+    end
+
+    def self.build(base, options)
+      # :limit => 1 --> :limit => [1]
+      options = options.inject({}){|h,kv| h[kv[0]]||=[]; h[kv[0]] << kv[1]; h}
+      new(base, options)
+    end
+
+    def scoped(options)
+      merged = @options.dup
+      if options.is_a?(Scope)
+        # merge in raw options e.g. :limit => [1, 2]
+        options.scope_options.each do |k,v|
+          old = merged[k] || []
+          merged[k] = v
+          old.each{|x| merged[k] << x }
+        end
+      else
+        # merge in a normal hash e.g. :limit => 1
+        merged = @options.dup
+        options.each do |k,v|
+          merged[k] ||= []
+          merged[k] << v
+        end
+      end
+      self.class.new(@base, merged)
+    end
+
+    def to_hash
+      result = if @base.respond_to?(:scope_to_hash)
+        @base.scope_to_hash(@options)
+      else
+        @options.map do |k,v|
+          result = case k
+          when :limit, :offset then v.min
+          when :order then v * ', '
+          else v
+          end
+          [k, result]
+        end
+      end
+
+      if result.is_a?(Hash)
+        result
+      else
+        # convert array to hash
+        result.inject({}){|h, kv| h[kv[0]] = kv[1]; h}
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @base.respond_to?("#{method_name}_scope_options")
+        # the method we call is a scope, continue chaining
+        scope = @base.send(method_name, *args)
+        scope.scoped(self)
+      else
+        # the method we call is a normal method, flatten everything
+        options = (args.first||{})
+        options = options.merge(:limit => 1) if method_name.to_sym == :first
+        options = scoped(options).to_hash
+        @base.send(method_name, options, &block)
+      end
+    end
+  end
+end

data/scopify.gemspec

@@ -0,0 +1,48 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{scopify}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser"]
+  s.date = %q{2010-05-13}
+  s.email = %q{grosser.michael@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "README.md",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/scopify.rb",
+     "lib/scopify/scope.rb",
+     "scopify.gemspec",
+     "spec/scopify_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/grosser/scopify}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Add named scopes and scoped to any Object / Model.}
+  s.test_files = [
+    "spec/scopify_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/scopify_spec.rb

@@ -0,0 +1,103 @@
+require 'spec/spec_helper'
+
+class T1
+  include Scopify
+
+  def self.foo(options)
+    options
+  end
+
+  def self.first(options)
+    options
+  end
+end
+
+class T2
+  include Scopify
+
+  def self.foo(options)
+    options
+  end
+
+  def self.scope_to_hash(options)
+    options.map do |k,v|
+      [k, v[0]+v[1]]
+    end
+  end
+end
+
+describe Scopify do
+  describe :scoped do
+    it "returns a new scope" do
+      T1.scoped({}).class.should == Scopify::Scope
+    end
+
+    it "can call anything on scope to reach base" do
+      T1.scoped({:limit => 1}).foo.should == {:limit => 1}
+    end
+
+    it "can call anything giving additional options" do
+      T1.scoped({:limit => 1}).foo(:offset => 1).should == {:limit => 1, :offset => 1}
+    end
+
+    it "adds limit => 1 to first queries" do
+      T1.scoped({:order => 'FOO'}).first.should == {:limit => 1, :order => 'FOO'}
+    end
+
+    it "can stack" do
+      T1.scoped(:limit => 1).scoped(:order => 'X').foo.should == {:limit => 1, :order => 'X'}
+    end
+
+    it "overwrites limit with the minimum" do
+      T1.scoped(:limit => 1).scoped(:limit => 2).foo.should == {:limit => 1}
+      T1.scoped(:limit => 2).scoped(:limit => 1).foo.should == {:limit => 1}
+    end
+
+    it "overwrites offset with the minimum" do
+      T1.scoped(:offset => 1).scoped(:offset => 2).foo.should == {:offset => 1}
+      T1.scoped(:offset => 2).scoped(:offset => 1).foo.should == {:offset => 1}
+    end
+
+    it "can use custom scope_to_hash" do
+      T2.scoped(:offset => 1).scoped(:offset => 2).foo.should == {:offset => 3}
+    end
+
+    it "does not mess with arrays" do
+      T2.scoped(:x => [[1]]).scoped(:x => [[2]]).scope_options.should == {:x => [[[1]], [[2]]]}
+    end
+  end
+
+  describe :scope do
+    it "adds a named scope" do
+      T1.scope(:yyy, :limit => 1)
+      T1.yyy.foo.should == {:limit => 1}
+    end
+
+    it "can add a scoped scope" do
+      T1.scope(:xxx, :limit => 1)
+      T1.scope(:xxx2, T1.xxx.scoped(:offset => 1))
+      T1.xxx2.foo.should == {:limit => 1, :offset => 1}
+    end
+
+    it "can add scope with arguments" do
+      T1.scope(:aaa, lambda{|a| {:limit => a}})
+      T1.aaa(1).foo.should == {:limit => 1}
+    end
+
+    it "can stack scopes by name" do
+      T1.scope(:bbb, :limit => 1)
+      T1.scope(:bbb2, :offset => 1)
+      T1.bbb.bbb2.foo.should == {:limit => 1, :offset => 1}
+    end
+
+    it "keeps oder when stacking by name" do
+      T1.scope(:ccc, :order => 'a')
+      T1.scope(:ccc2, :order => 'b')
+      T1.ccc2.ccc.foo.should == {:order => 'b, a'}
+    end
+  end
+
+  it "has a VERSION" do
+    Scopify::VERSION.should =~ /^\d+\.\d+\.\d+$/
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH << 'lib'
+require 'scopify'

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: scopify
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-13 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: grosser.michael@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- init.rb
+- lib/scopify.rb
+- lib/scopify/scope.rb
+- scopify.gemspec
+- spec/scopify_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/grosser/scopify
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Add named scopes and scoped to any Object / Model.
+test_files: 
+- spec/scopify_spec.rb
+- spec/spec_helper.rb