doorkeeper 0.3.4 → 0.4.0

data/lib/doorkeeper/config/scope.rb

@@ -1,11 +0,0 @@
-module Doorkeeper
-  class Scope
-    attr_reader :name, :default, :description
-
-    def initialize(name, options = {})
-      @name = name
-      @default = options[:default] || false
-      @description = options[:description]
-    end
-  end
-end

data/lib/doorkeeper/config/scopes.rb

@@ -1,61 +0,0 @@
-module Doorkeeper
-  class Scopes
-    include Enumerable
-    REQUIRED_ELEMENT_METHOD = [:name, :default]
-
-    class IllegalElement < StandardError; end
-
-    delegate :each, :to => :@scopes
-
-    def initialize
-      @scopes = []
-    end
-
-    def [](name)
-      select do |scope|
-        scope.name.to_sym == name.to_sym
-      end.first
-    end
-
-    def exists? (scope)
-      self[scope].present?
-    end
-
-    def all_included?(scopes_string)
-      scopes_string.split(" ").all? { |s| self.exists?(s) }
-    end
-
-    def add (scope)
-      raise IllegalElement unless valid_element?(scope)
-      @scopes << scope
-    end
-
-    def all
-      @scopes
-    end
-
-    def defaults
-      select do |scope|
-        scope.default
-      end
-    end
-
-    def default_scope_string
-      defaults.map(&:name).join(" ")
-    end
-
-    def with_names(*names)
-      names = names.map(&:to_sym)
-      select do |scope|
-        names.include? scope.name.to_sym
-      end
-    end
-
-    private
-    def valid_element?(scope)
-      REQUIRED_ELEMENT_METHOD.all? do |method|
-        scope.respond_to? method
-      end
-    end
-  end
-end

data/lib/doorkeeper/config/scopes_builder.rb

@@ -1,18 +0,0 @@
-module Doorkeeper
-  class Config
-    class ScopesBuilder
-      def initialize(&block)
-        @scopes = Doorkeeper::Scopes.new
-        instance_eval &block
-      end
-
-      def build
-        @scopes
-      end
-
-      def scope(name, options)
-        @scopes.add Doorkeeper::Scope.new(name, options)
-      end
-    end
-  end
-end

data/spec/dummy/config/initializers/inflections.rb

@@ -1,10 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Add new inflection rules using the following format
-# (all these examples are active by default):
-# ActiveSupport::Inflector.inflections do |inflect|
-#   inflect.plural /^(ox)$/i, '\1en'
-#   inflect.singular /^(ox)en/i, '\1'
-#   inflect.irregular 'person', 'people'
-#   inflect.uncountable %w( fish sheep )
-# end

data/spec/dummy/config/initializers/mime_types.rb

@@ -1,5 +0,0 @@
-# Be sure to restart your server when you modify this file.
-
-# Add new mime types for use in respond_to blocks:
-# Mime::Type.register "text/richtext", :rtf
-# Mime::Type.register_alias "text/html", :iphone

data/spec/lib/config/scope_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper
-  describe Scope do
-    context 'initialized only with name' do
-      subject do
-        Scope.new("public")
-      end
-
-      it "has a given name" do
-        subject.name.should == "public"
-      end
-
-      it "has default set to false" do
-        subject.default.should be_false
-      end
-
-      it "has no description" do
-        subject.description.should be_nil
-      end
-    end
-
-    context 'initialized with options' do
-      let :description do
-        "Paranoic scope"
-      end
-
-      subject do
-        Scope.new("write", :default => true, :description => description)
-      end
-
-      it "has given name" do
-        subject.name.should == "write"
-      end
-
-      it "has given value of default" do
-        subject.default.should be_true
-      end
-
-      it "has given valud of description" do
-        subject.description.should == description
-      end
-    end
-  end
-end

data/spec/lib/config/scopes_builder_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper_integration'
-
-module Doorkeeper
-  describe Config::ScopesBuilder do
-    context 'provides DSL to create Scopes collection' do
-      subject do
-        Config::ScopesBuilder.new do
-          scope :public, :default => true, :description => "A"
-          scope :write, :description => "B"
-        end
-      end
-
-      describe :build do
-        it 'returns Scopes instance' do
-          subject.build.should be_a(Doorkeeper::Scopes)
-        end
-
-        it 'contains defined scopes' do
-          scopes = subject.build
-          scopes.all.should have(2).items
-          scopes[:public].description.should == "A"
-          scopes[:write].description.should == "B"
-        end
-      end
-    end
-  end
-end

data/spec/lib/config/scopes_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/string'
-require 'doorkeeper/config/scopes'
-require 'doorkeeper/config/scope'
-
-module Doorkeeper
-  describe Scopes do
-    before :each do
-      if defined? scopes_array
-        scopes_array.each do |scope|
-          subject.add scope
-        end
-      end
-    end
-
-    describe :add do
-      it 'allows you to add scopes' do
-        scope = create_scope "public", false
-        subject.add scope
-        subject.all.should == [scope]
-      end
-
-      it 'raises error if you try to add illegal element' do
-        expect do
-          subject.add double
-        end.to raise_error Doorkeeper::Scopes::IllegalElement
-      end
-    end
-
-    describe :[] do
-      let :public_scope do
-        create_scope "public", false
-      end
-
-      let :write_scope do
-        create_scope "write", false
-      end
-
-      subject do
-        Scopes.new.tap do |scopes|
-          scopes.add public_scope
-          scopes.add write_scope
-        end
-      end
-
-      it 'returns the scope with given name' do
-        subject[:public].should == public_scope
-        subject[:write].should == write_scope
-      end
-
-      it 'returns nil if there does not exist scope with given name' do
-        subject[:awesome].should be_nil
-      end
-    end
-
-    describe :exists? do
-      subject do
-        Scopes.new.tap do |scopes|
-          scopes.add create_scope "public", false
-        end
-      end
-
-      it 'returns true if scope with given name is present' do
-        subject.exists?("public").should be_true
-      end
-
-      it 'returns false if scope with given name does not exist' do
-        subject.exists?("other").should be_false
-      end
-
-      it 'handles symbols' do
-        subject.exists?(:public).should be_true
-        subject.exists?(:other).should be_false
-      end
-    end
-
-    describe :all do
-      let :scopes_array do
-        create_scopes_array "scope1", true,
-                            "scope2", false,
-                            "scope3", true
-      end
-
-      it "returns all added scopes" do
-        subject.all.should == scopes_array
-      end
-    end
-
-    describe :defaults do
-      let :default_scopes do
-        create_scopes_array "public", true,
-                            "other_public", true
-      end
-
-      let :scopes_array do
-        array = create_scopes_array "awesome", false,
-                                    "awesome2", false
-        array + default_scopes
-      end
-
-      it "returns scopes with a default flag" do
-        subject.defaults.should == default_scopes
-      end
-    end
-
-    describe :with_names do
-      let :scopes_array do
-        create_scopes_array "scope1", true,
-                            "scope2", false,
-                            "scope3", false
-
-      end
-
-      it "returns array of scopes with given names" do
-        returned_scopes = subject.with_names("scope1", "scope3")
-        returned_scopes.should have(2).items
-        returned_scopes.map(&:name).should include("scope1", "scope3")
-
-      end
-    end
-
-    describe :default_scope_string do
-      let :default_scopes do
-        create_scopes_array "public", true,
-                            "other_public", true
-      end
-
-      let :scopes_array do
-        array = create_scopes_array "awesome", false,
-                                    "awesome2", false
-        array + default_scopes
-      end
-
-      it "returns the string that joins names of default scopes" do
-        subject.default_scope_string.should == "public other_public"
-      end
-
-    end
-
-    describe :all_included? do
-      subject do
-        Scopes.new.tap do |s|
-          s.add create_scope("public", true)
-          s.add create_scope("write", false)
-        end
-      end
-
-      it "is true if any scopes is included" do
-        subject.all_included?("public").should be_true
-      end
-
-      it "is true if all scopes are included" do
-        subject.all_included?("public write").should be_true
-      end
-
-      it "is true if all scopes are included in any order" do
-        subject.all_included?("write public").should be_true
-      end
-
-      it "is false if no scopes are included" do
-        subject.all_included?("notexistent").should be_false
-      end
-
-      it "is false if no scopes are included even for existing ones" do
-        subject.all_included?("public write notexistent").should be_false
-      end
-    end
-
-    def create_scopes_array(*args)
-      args.each_slice(2).map do |slice|
-        create_scope(*slice)
-      end
-    end
-
-    def create_scope(name, default)
-      Scope.new(name, :default => default)
-    end
-  end
-end