ldap-filter 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ldap-filter.gemspec
+gemspec

data/README.md

@@ -0,0 +1,34 @@
+# ldap-filter
+
+While working on a Rails application that leaned heavily on my school's LDAP server, I started off writing inflexible methods like:
+
+    def uid_filter(uid)
+      "(uid=#{uid})"
+    end
+
+    def uid_or_email_filter(uid, email)
+      "(|(#{uid_filter(uid)})(#{email_filter(email)}))"
+    end
+
+And decided it would be easier to do:
+
+    filter = LDAP::Filter::Base.new :uid, 'mrhalp' # (uid=mrhalp)
+    if search[:email] # mrhalp@email.org
+      email = LDAP::Filter::Base.new :mail, search[:email]
+      filter = filter | email
+    end
+    MyLDAPLibrary.search filter.to_s # (|(email=mrhalp@email.org)(uid=mrhalp))
+
+You also don't have to worry about all those nested parentheses.
+
+## Install
+
+    gem install ldap-filter
+
+With Bundler:
+
+    gem 'ldap-filter'
+
+## Usage
+
+More to come soon.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/ldap-filter.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ldap/filter/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ldap-filter"
+  s.version     = LDAP::Filter::VERSION
+  s.authors     = ["Eduardo Gutierrez"]
+  s.email       = ["edd_d@mit.edu"]
+  s.homepage    = "https://github.com/ecbypi/ldap-filter"
+  s.summary     = %q{DSL for building LDAP filters}
+  s.description = %q{DSL for dynamically building complex LDAP filters without concern for closing parentheses}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+end

data/lib/ldap-filter.rb

@@ -0,0 +1 @@
+require 'ldap/filter'

data/lib/ldap/filter.rb

@@ -0,0 +1,5 @@
+require "ldap/filter/version"
+require 'ldap/filter/base'
+require 'ldap/filter/compound'
+require 'ldap/filter/and_filter'
+require 'ldap/filter/or_filter'

data/lib/ldap/filter/and_filter.rb

@@ -0,0 +1,10 @@
+module LDAP
+  module Filter
+    class AndFilter < Compound
+
+      def initialize *args
+        super '&', *args
+      end
+    end
+  end
+end

data/lib/ldap/filter/base.rb

@@ -0,0 +1,43 @@
+module LDAP
+  module Filter
+    class Base
+      attr_accessor :key, :value
+
+      def initialize key, value, inverse=false
+        @key = key
+        @value = value.to_s
+        @not = inverse
+      end
+
+      def to_s
+        filter = '('
+        filter << '!' if @not
+        filter << condition
+        filter << ')'
+      end
+
+      def !
+        @not = !@not
+        self
+      end
+
+      def << value
+        OrFilter.new @key, @value, value
+      end
+
+      def | filter
+        OrFilter.new [self, filter]
+      end
+
+      def & filter
+        AndFilter.new [self, filter]
+      end
+
+      private
+
+      def condition
+        [@key, '=', @value].join
+      end
+    end
+  end
+end

data/lib/ldap/filter/compound.rb

@@ -0,0 +1,64 @@
+module LDAP
+  module Filter
+    class Compound
+
+      attr_reader :children, :operator
+
+      def initialize operator, key_or_mappings, *values
+        @children = case key_or_mappings
+                    when Symbol then populate_from_values key_or_mappings, values
+                    when Array then grep key_or_mappings
+                    when Hash then populate_from_hash key_or_mappings
+                    end
+        @operator = operator unless @operator
+      end
+
+      def to_s
+        filter = '('
+        filter << @operator.to_s
+        filter << @children.map(&:to_s).join
+        filter << ')'
+      end
+
+      def << filter
+        raise ArgumentError, 'invalid representation of a filter' unless valid_filter?(filter)
+        @children << filter
+      end
+
+      def | filter
+        OrFilter.new [self, filter]
+      end
+
+      def & filter
+        AndFilter.new [self, filter]
+      end
+
+      private
+
+      def valid_filter? filter
+        filter.kind_of?(Base) ||
+          filter.kind_of?(Compound)
+      end
+
+      def grep filters
+        filters.select { |filter| valid_filter? filter }
+      end
+
+      def populate_from_hash mappings
+        raise ArgumentError, 'compound filters require more than one key' if mappings.keys.size < 2
+        mappings.map do |key, values|
+          case values
+          when Array then Compound.new('|', key, *values)
+          else Base.new(key, values)
+          end
+        end
+      end
+
+      def populate_from_values key, values
+        raise ArgumentError, 'need more than one value for compound filter on the same key' if values.size < 2
+        @operator = '|' # Cannot &'d values on the same key
+        values.map { |value| Base.new(key, value) }
+      end
+    end
+  end
+end

data/lib/ldap/filter/or_filter.rb

@@ -0,0 +1,10 @@
+module LDAP
+  module Filter
+    class OrFilter < Compound
+
+      def initialize *args
+        super '|', *args
+      end
+    end
+  end
+end

data/lib/ldap/filter/version.rb

@@ -0,0 +1,5 @@
+module LDAP
+  module Filter
+    VERSION = "0.0.1"
+  end
+end

data/spec/filter/and_filter_spec.rb

@@ -0,0 +1,13 @@
+require 'ldap-filter'
+
+module LDAP
+  module Filter
+    describe AndFilter do
+
+      it "subclases LDAP::Filter::Compound, defaulting the operator to :&" do
+        filter = AndFilter.new(givenName: 'John', sn: 'Smith')
+        filter.operator.to_s.should eq '&'
+      end
+    end
+  end
+end

data/spec/filter/base_spec.rb

@@ -0,0 +1,51 @@
+require 'ldap-filter'
+
+module LDAP
+  module Filter
+
+    describe Base do
+      let(:filter) { Base.new(:givenName, 'John') }
+
+      describe "#to_s" do
+        it "puts together the pieces and returns usable filter" do
+          filter.to_s.should eq '(givenName=John)'
+        end
+      end
+
+      describe "#!" do
+        it "inverts the filter" do
+          !filter
+          filter.to_s.should eq '(!givenName=John)'
+        end
+      end
+
+      describe "compound methods" do
+        let(:other) { Base.new(:sn, 'Smith') }
+
+        describe "#<<" do
+          it "creates an OrFilter object under the same key" do
+            compound = filter << 'Smith'
+            compound.should be_a OrFilter
+            compound.to_s.should eq '(|(givenName=John)(givenName=Smith))'
+          end
+        end
+
+        describe "#|" do
+          it "builds an OrFilter of itself and the argument filter" do
+            compound = filter | other
+            compound.should be_a OrFilter
+            compound.to_s.should eq '(|(givenName=John)(sn=Smith))'
+          end
+        end
+
+        describe "#&" do
+          it "builds an AndFilter of itself and the argument filter" do
+            compound = filter & other
+            compound.should be_a AndFilter
+            compound.to_s.should eq '(&(givenName=John)(sn=Smith))'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/filter/compound_spec.rb

@@ -0,0 +1,106 @@
+require 'ldap-filter'
+
+module LDAP
+  module Filter
+
+    describe Compound do
+      let(:operator) { '&' } # AndOperator
+
+      describe "#to_s" do
+        it "builds all children filters and combines them with the operator" do
+          filter = Compound.new(operator, { givenName: 'John', sn: ['Smith', 'Smithers']})
+          filter.to_s.should eq '(&(givenName=John)(|(sn=Smith)(sn=Smithers)))'
+        end
+      end
+
+      describe "can be built from a hash" do
+        it "with key value pairs for base filters" do
+          attributes = {
+            givenName: 'John',
+            sn: 'Smith'
+          }
+          filter = Compound.new(operator, attributes)
+          filter.children.size.should eq 2
+          filter.children.first.should be_instance_of LDAP::Filter::Base
+        end
+
+        it "with key values pairs to create nested compound filters" do
+          attributes = {
+            givenName: ['John', 'Mary', 'Tyler'],
+            sn: 'Smith'
+          }
+          filter = Compound.new(operator, attributes)
+          filter.children.size.should eq 2
+          filter.children.first.should be_a LDAP::Filter::Compound
+          filter.children.first.children.size.should eq 3
+        end
+
+        it "so long as more than one key is supplied" do
+          expect { Compound.new('|', { givenName: 'John' }) }.to raise_error ArgumentError
+        end
+      end
+
+      describe "can be built from an array of string values" do
+        it "can be built using a key and an array of values" do
+          filter = Compound.new(operator, :givenName, 'Mary', 'John', 'Tyler')
+          filter.operator.should eq '|'
+          filter.children.size.should eq 3
+        end
+
+        it "so long as there is more than one value provided" do
+          expect { Compound.new('|', :givenName, 'Mary') }.to raise_error ArgumentError
+        end
+      end
+
+      describe "when built from other filter objects" do
+        let(:given_name) { Base.new(:givenName, 'John') }
+        let(:surname) { Base.new(:sn, 'Smith') }
+
+        it "is done using an array of filter objects" do
+          filter = Compound.new(operator, [given_name, surname])
+          filter.children.size.should eq 2
+          filter.children.first.should eq given_name
+          filter.children.last.should eq surname
+        end
+
+        it "takes out non-filter objects when built with an array of filters" do
+          filter = Compound.new(operator, [given_name, surname, 'invalid'])
+          filter.children.size.should eq 2
+        end
+      end
+
+      describe "compound methods" do
+        let(:compound) { Compound.new '|', { givenName: 'John', sn: 'Smith' } }
+        let(:base) { Base.new :mail, 'smith@email.org' }
+
+        describe "#<<" do
+          it "adds a filter to it's children" do
+            expect { compound << base }.to change { compound.children.size }.by 1
+          end
+
+          it "only accepts filter objects" do
+            expect { compound << 'smith@email.org' }.to raise_error ArgumentError
+          end
+        end
+
+        describe "#|" do
+          it "creates a new OrFilter" do
+            new_filter = compound | base
+            new_filter.children.should include(compound)
+            new_filter.children.should include(base)
+            new_filter.operator.should eq '|'
+          end
+        end
+
+        describe "#&" do
+          it "creates a new AndFilter" do
+            new_filter = compound & base
+            new_filter.children.should include(compound)
+            new_filter.children.should include(base)
+            new_filter.operator.should eq '&'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/filter/or_filter_spec.rb

@@ -0,0 +1,13 @@
+require 'ldap-filter'
+
+module LDAP
+  module Filter
+    describe OrFilter do
+
+      it "subclases LDAP::Filter::Compound, defaulting the operator to :&" do
+        filter = OrFilter.new(givenName: 'John', sn: 'Smith')
+        filter.operator.to_s.should eq '|'
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ldap-filter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Eduardo Gutierrez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-28 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70129611592680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70129611592680
+description: DSL for dynamically building complex LDAP filters without concern for
+  closing parentheses
+email:
+- edd_d@mit.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- ldap-filter.gemspec
+- lib/ldap-filter.rb
+- lib/ldap/filter.rb
+- lib/ldap/filter/and_filter.rb
+- lib/ldap/filter/base.rb
+- lib/ldap/filter/compound.rb
+- lib/ldap/filter/or_filter.rb
+- lib/ldap/filter/version.rb
+- spec/filter/and_filter_spec.rb
+- spec/filter/base_spec.rb
+- spec/filter/compound_spec.rb
+- spec/filter/or_filter_spec.rb
+homepage: https://github.com/ecbypi/ldap-filter
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: DSL for building LDAP filters
+test_files:
+- spec/filter/and_filter_spec.rb
+- spec/filter/base_spec.rb
+- spec/filter/compound_spec.rb
+- spec/filter/or_filter_spec.rb