flexselect 1.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Emmanuel Oga for Broadspire, Inc
+
+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.rdoc

@@ -0,0 +1,28 @@
+= flexselect
+
+This gem is just a convenient packaging of the excellent
+
+jQuery plugin flexselect.
+
+http://github.com/rmm5t/jquery-flexselect/
+
+A very little modification was made to the flexselect()
+function arguments for making it more convenient to use with Rails.
+
+In addition it provides an ActiveRecord class method to configure
+certain attributes for autocompletion.
+
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Emmanuel Oga for Broadspire, Inc. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flexselect"
+    gem.summary = %Q{A jQuery plugin and an activerecord extension to provide auto-complete on html select tags}
+    gem.description = %Q{For rails applications, requires jQuery}
+    gem.email = "EmmanuelOga@gmail.com"
+    gem.homepage = "http://github.com/EmmanuelOga/flexselect"
+    gem.authors = ["Emmanuel Oga"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", ">= 0"
+    gem.add_development_dependency "activerecord", ">= 0"
+    gem.add_development_dependency "sqlite3-ruby", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/generators/flexselect/USAGE

@@ -0,0 +1,19 @@
+Description:
+    Just copies the javascript and css stylesheets you need to the public directory.
+    NOTE: you need to include jQuery on your html page for the plugin to work.
+
+Example:
+    ./script/generate flexselect
+
+    This will create:
+
+        public/stylesheets/flexselect.css
+        public/javascripts/jquery.flexselect.js
+        public/javascripts/liquidmetal.js
+
+    Later, on your template:
+
+        <%= stylesheet_link_tag "flexselect.css" %>
+        <%= javascript_include_tag "jquery.js", "liquidmetal.js", "jquery.flexselect.js" %>
+
+    You get the idea.

data/generators/flexselect/flexselect_generator.rb

@@ -0,0 +1,9 @@
+class FlexselectGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.template "flexselect.css"       , "public/stylesheets/flexselect.css"
+      m.template "jquery.flexselect.js" , "public/javascripts/jquery.flexselect.js"
+      m.template "liquidmetal.js"       , "public/javascripts/liquidmetal.js"
+    end
+  end
+end

data/generators/flexselect/templates/flexselect.css

@@ -0,0 +1,40 @@
+.flexselect_dropdown {
+  display: none;
+  position: absolute;
+  z-index: 999;
+  margin: 0;
+  padding: 0;
+  border: 1px solid WindowFrame;
+  max-height: 200px;
+  overflow-x: hidden;
+  overflow-y: auto;
+  background-color: Window;
+  color: WindowText;
+  color: #777;
+  text-align: left;
+  box-shadow: 0 6px 12px #ccc;
+  -webkit-box-shadow: 0 6px 12px #ccc;
+}
+
+.flexselect_dropdown ul {
+  width: 100%;
+  list-style-position: outside;
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.flexselect_dropdown li {
+  margin: 0px;
+  padding: 2px 5px;
+  cursor: pointer;
+  display: block;
+  width: 100%;
+  font: Menu;
+  overflow: hidden;
+}
+
+.flexselect_selected {
+  background-color: Highlight;
+  color: HighlightText;
+}

data/generators/flexselect/templates/jquery.flexselect.js

@@ -0,0 +1,284 @@
+/*
+ * flexselect: a jQuery plugin, version: %RELEASE_VERSION% (%RELEASE_DATE%)
+ * @requires jQuery v1.3 or later
+ *
+ * FlexSelect is a jQuery plugin that makes it easy to convert a select box into
+ * a Quicksilver-style, autocompleting, flex matching selection tool.
+ *
+ * For usage and examples, visit:
+ * http://rmm5t.github.com/jquery-flexselect/
+ *
+ * Licensed under the MIT:
+ * http://www.opensource.org/licenses/mit-license.php
+ *
+ * Copyright (c) 2009, Ryan McGeary (ryanonjavascript -[at]- mcgeary [*dot*] org)
+ *
+ * Modified by Emmanuel Oga, see for details on
+ *
+ *   http://github.com/EmmanuelOga/flexselect
+ *
+ * Copyright (c) 2010, Emmanuel Oga for Broadspire Inc.
+ */
+(function($) {
+  $.flexselect = function(select, options) { this.init(select, options); };
+
+  $.extend($.flexselect.prototype, {
+    settings: {
+      allowMismatch: false,
+      selectedClass: "flexselect_selected",
+      dropdownClass: "flexselect_dropdown",
+      inputIdTransform:    function(id)   { return id + "_flexselect"; },
+      inputNameTransform:  function(name) { return; },
+      dropdownIdTransform: function(id)   { return id + "_flexselect_dropdown"; }
+    },
+    select: null,
+    input: null,
+    hidden: null,
+    dropdown: null,
+    dropdownList: null,
+    cache: [],
+    results: [],
+    lastAbbreviation: null,
+    abbreviationBeforeFocus: null,
+    selectedIndex: 0,
+    picked: false,
+    dropdownMouseover: false, // Workaround for poor IE behaviors
+
+    init: function(select, options) {
+      $.extend(this.settings, options);
+      this.select = $(select);
+      this.preloadCache();
+      this.renderControls();
+      this.wire();
+    },
+
+    preloadCache: function() {
+      this.cache = this.select.children("option").map(function() {
+        return { name: $.trim($(this).text()), value: $(this).val(), score: 0.0 };
+      });
+    },
+
+    renderControls: function() {
+      var selected = this.select.children("option:selected");
+
+      this.hidden = $("<input type='hidden'/>").attr({
+        id: this.select.attr("id"),
+        name: this.select.attr("name")
+      }).val(selected.val());
+
+      this.input = $("<input type='text' autocomplete='off' />").attr({
+        id: this.settings.inputIdTransform(this.select.attr("id")),
+        name: this.settings.inputNameTransform(this.select.attr("name")),
+        accesskey: this.select.attr("accesskey"),
+        tabindex: this.select.attr("tabindex"),
+        style: this.select.attr("style")
+      }).addClass(this.select.attr("class")).val($.trim(selected.text()));
+
+      this.dropdown = $("<div></div>").attr({
+        id: this.settings.dropdownIdTransform(this.select.attr("id"))
+      }).addClass(this.settings.dropdownClass);
+      this.dropdownList = $("<ul></ul>");
+      this.dropdown.append(this.dropdownList);
+
+      this.select.after(this.input).after(this.hidden).remove();
+      $("body").append(this.dropdown);
+    },
+
+    wire: function() {
+      var self = this;
+
+      this.input.click(function() {
+        self.lastAbbreviation = null;
+        self.focus();
+      });
+
+      this.input.mouseup(function(event) {
+        // This is so Safari selection actually occurs.
+        event.preventDefault();
+      });
+
+      this.input.focus(function() {
+        self.abbreviationBeforeFocus = self.input.val();
+        self.input.select();
+        if (!self.picked) self.filterResults();
+      });
+
+      this.input.blur(function() {
+        if (!self.dropdownMouseover) {
+          self.hide();
+          if (!self.picked) self.reset();
+        }
+      });
+
+      this.dropdownList.mouseover(function (event) {
+        if (event.target.tagName == "LI") {
+          var rows = self.dropdown.find("li");
+          self.markSelected(rows.index($(event.target)));
+        }
+      });
+      this.dropdownList.mouseleave(function () {
+        self.markSelected(-1);
+      });
+      this.dropdownList.mouseup(function (event) {
+        self.pickSelected();
+        self.focusAndHide();
+      });
+      this.dropdown.mouseover(function (event) {
+        self.dropdownMouseover = true;
+      });
+      this.dropdown.mouseleave(function (event) {
+        self.dropdownMouseover = false;
+      });
+      this.dropdown.mousedown(function (event) {
+        event.preventDefault();
+      });
+
+      this.input.keyup(function(event) {
+        switch (event.keyCode) {
+          case 13: // return
+            event.preventDefault();
+            self.pickSelected();
+            self.focusAndHide();
+            break;
+          case 27: // esc
+            event.preventDefault();
+            self.reset();
+            self.focusAndHide();
+            break;
+          default:
+            self.filterResults();
+            break;
+        }
+      });
+
+      this.input.keydown(function(event) {
+        switch (event.keyCode) {
+          case 9:  // tab
+            self.pickSelected();
+            self.hide();
+            break;
+          case 33: // pgup
+            event.preventDefault();
+            self.markFirst();
+            break;
+          case 34: // pgedown
+            event.preventDefault();
+            self.markLast();
+            break;
+          case 38: // up
+            event.preventDefault();
+            self.moveSelected(-1);
+            break;
+          case 40: // down
+            event.preventDefault();
+            self.moveSelected(1);
+            break;
+          case 13: // return
+          case 27: // esc
+            event.preventDefault();
+            event.stopPropagation();
+            break;
+        }
+      });
+    },
+
+    filterResults: function() {
+      var abbreviation = this.input.val();
+      if (abbreviation == this.lastAbbreviation) return;
+
+      var results = [];
+      $.each(this.cache, function() {
+        this.score = LiquidMetal.score(this.name, abbreviation);
+        if (this.score > 0.0) results.push(this);
+      });
+      this.results = results;
+
+      this.sortResults();
+      this.renderDropdown();
+      this.markFirst();
+      this.lastAbbreviation = abbreviation;
+      this.picked = false;
+    },
+
+    sortResults: function() {
+      this.results.sort(function(a, b) { return b.score - a.score; });
+    },
+
+    renderDropdown: function() {
+      var dropdownBorderWidth = this.dropdown.outerWidth() - this.dropdown.innerWidth();
+      var inputOffset = this.input.offset();
+      this.dropdown.css({
+        width: (this.input.outerWidth() - dropdownBorderWidth) + "px",
+        top: (inputOffset.top + this.input.outerHeight()) + "px",
+        left: inputOffset.left + "px"
+      });
+
+      var list = this.dropdownList.html("");
+      $.each(this.results, function() {
+        // list.append($("<li/>").html(this.name + " <small>[" + Math.round(this.score*100)/100 + "]</small>"));
+        list.append($("<li/>").html(this.name));
+      });
+      this.dropdown.show();
+    },
+
+    markSelected: function(n) {
+      if (n > this.results.length) return;
+
+      var rows = this.dropdown.find("li");
+      rows.removeClass(this.settings.selectedClass);
+      this.selectedIndex = n;
+
+      if (n >= 0) $(rows[n]).addClass(this.settings.selectedClass);
+    },
+
+    pickSelected: function() {
+      var selected = this.results[this.selectedIndex];
+      if (selected) {
+        this.input.val(selected.name);
+        this.hidden.val(selected.value);
+        this.picked = true;
+      } else if (this.settings.allowMismatch) {
+        this.hidden.val("");
+      } else {
+        this.reset();
+      }
+    },
+
+    hide: function() {
+      this.dropdown.hide();
+      this.lastAbbreviation = null;
+    },
+
+    moveSelected: function(n) { this.markSelected(this.selectedIndex+n); },
+    markFirst:    function()  { this.markSelected(0); },
+    markLast:     function()  { this.markSelected(this.results.length - 1); },
+    reset:        function()  { this.input.val(this.abbreviationBeforeFocus); },
+    focus:        function()  { this.input.focus(); },
+    focusAndHide: function()  { this.focus(); this.hide(); }
+  });
+
+  $.fn.flexselect = function() {
+    // EOGA: Little modification for the flexselect gem.
+    // Allow the user to provide just two options,
+    // name of the activerecord class and name of the attribute to autocomplete.
+    // The third parameter can contain the options object as before.
+    var options;
+
+    if (arguments.length == 1) { var object_opt = arguments[0]; } else { var array_opt = arguments; }
+
+    this.each(function() {
+      if (array_opt) {
+        var transf = function(id) { return array_opt[0] + "[" + array_opt[1] + "]"; }
+        options = { allowMismatch: true, inputIdTransform: transf };
+
+        // Allow additional options to follow the string params
+        if (array_opt[2]) $.extend(options, array_opt[2]);
+      } else {
+        options = object_opt;
+      }
+
+      if (this.tagName == "SELECT") new $.flexselect(this, options);
+    });
+    return this;
+  };
+})(jQuery);

data/generators/flexselect/templates/liquidmetal.js

@@ -0,0 +1,88 @@
+/*
+ * LiquidMetal, version: 0.1 (2009-02-05)
+ *
+ * A mimetic poly-alloy of Quicksilver's scoring algorithm, essentially
+ * LiquidMetal.
+ *
+ * For usage and examples, visit:
+ * http://github.com/rmm5t/liquidmetal
+ *
+ * Licensed under the MIT:
+ * http://www.opensource.org/licenses/mit-license.php
+ *
+ * Copyright (c) 2009, Ryan McGeary (ryanonjavascript -[at]- mcgeary [*dot*] org)
+ */
+var LiquidMetal = function() {
+  var SCORE_NO_MATCH = 0.0;
+  var SCORE_MATCH = 1.0;
+  var SCORE_TRAILING = 0.8;
+  var SCORE_TRAILING_BUT_STARTED = 0.9;
+  var SCORE_BUFFER = 0.85;
+
+  return {
+    score: function(string, abbreviation) {
+      // Short circuits
+      if (abbreviation.length == 0) return SCORE_TRAILING;
+      if (abbreviation.length > string.length) return SCORE_NO_MATCH;
+
+      var scores = this.buildScoreArray(string, abbreviation);
+
+      var sum = 0.0;
+      for (var i in scores) {
+        sum += scores[i];
+      }
+
+      return (sum / scores.length);
+    },
+
+    buildScoreArray: function(string, abbreviation) {
+      var scores = new Array(string.length);
+      var lower = string.toLowerCase();
+      var chars = abbreviation.toLowerCase().split("");
+
+      var lastIndex = -1;
+      var started = false;
+      for (var i in chars) {
+        var c = chars[i];
+        var index = lower.indexOf(c, lastIndex+1);
+        if (index < 0) return fillArray(scores, SCORE_NO_MATCH);
+        if (index == 0) started = true;
+
+        if (isNewWord(string, index)) {
+          scores[index-1] = 1;
+          fillArray(scores, SCORE_BUFFER, lastIndex+1, index-1);
+        }
+        else if (isUpperCase(string, index)) {
+          fillArray(scores, SCORE_BUFFER, lastIndex+1, index);
+        }
+        else {
+          fillArray(scores, SCORE_NO_MATCH, lastIndex+1, index);
+        }
+
+        scores[index] = SCORE_MATCH;
+        lastIndex = index;
+      }
+
+      var trailingScore = started ? SCORE_TRAILING_BUT_STARTED : SCORE_TRAILING;
+      fillArray(scores, trailingScore, lastIndex+1);
+      return scores;
+    }
+  };
+
+  function isUpperCase(string, index) {
+    var c = string.charAt(index);
+    return ("A" <= c && c <= "Z");
+  }
+
+   function isNewWord(string, index) {
+    var c = string.charAt(index-1);
+    return (c == " " || c == "\t");
+  }
+
+  function fillArray(array, value, from, to) {
+    from = Math.max(from || 0, 0);
+    to = Math.min(to || array.length, array.length);
+    for (var i = from; i < to; i++) { array[i] = value; }
+    return array;
+  }
+}();

data/install.rb

@@ -0,0 +1,3 @@
+puts "run the generator to create the js and css files you need to include in your html page."
+puts
+puts "script/generate flexselect"

data/lib/flexselect.rb

@@ -0,0 +1,55 @@
+module Flexselect
+
+  # Creates an virtual attribute to handle new values for
+  # an autocomplete select tag handled by flexquery and a callback
+  # to update the attribute using the virtual one.
+  #
+  # The name of the virtual attribute and the callback is derived
+  # from the name of the attribute:
+  #
+  #   attr_flex_selector :thing
+  #
+  # produces a virtual attribute named "flex_thing_input" and
+  # the private method "callback_for_flex_thing_input" for
+  # callback.
+  #
+  # Options:
+  #
+  #   attr   :: The attribute to autocomple
+  #
+  #   :on    :: ActiveRecord callback to use for updating the attribute.
+  #             Defaults to :before_validation_on_create
+  #
+  #   :if    :: A Proc that is called before updating the attribute.
+  #             defaults to lambda { |virtual_attribute_value| virtual_attribute_value.present? }
+  #
+  #   &block :: If provided, is called to get the new value for the attribute.
+  #             Defaults to lambda{ |virtual_attribute_value| virtual_attribute_value }
+  #
+  def attr_flex_selector(attr, options = {}, &block)
+    virtual_attribute = "flex_#{ attr }_input"
+    callback_method   = "callback_for_#{ virtual_attribute }"
+
+    attr_accessor virtual_attribute
+
+    if_lambda     = options[:if] || lambda { |new| new.present? }
+    action_lambda = block        || lambda { |new| new }
+
+    # A new Module allows to redefine method retaining the old one for "super" usage.
+    mod = Module.new do
+      define_method(callback_method) do
+        value = send(virtual_attribute)
+
+        if if_lambda.bind(self).call(value)
+          send "#{attr}=", action_lambda.bind(self).call(value)
+        end
+      end
+      private(callback_method)
+    end
+
+    include mod
+
+    send(options[:on] || :before_validation_on_create, callback_method)
+  end
+
+end

data/rails/init.rb

@@ -0,0 +1 @@
+ActiveRecord::Base.extend Flexselect

data/spec/active_record_helper.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+ActiveRecord::Schema.define do
+  create_table "things" do |t|
+    t.string :a, :b, :c, :d
+  end
+end

data/spec/flexselect_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class Thing < ActiveRecord::Base
+
+  attr_flex_selector :a
+
+  attr_flex_selector :b, :on => :after_save
+
+  attr_flex_selector :c, :if => lambda { |val| val && (val.to_i % 2 == 0) }
+
+  attr_flex_selector :d do |new|
+    [a, b, c, flex_d_input, new].join("-")
+  end
+end
+
+describe "Flexselect" do
+  it "should create an virtual attribute derived from the actual one" do
+    Thing.new.should respond_to("flex_a_input")
+    Thing.new.should respond_to("flex_a_input=")
+  end
+
+  describe "with defaults" do
+    it "should update the attribute with the value on the virtual attribute if it is present" do
+      thing = Thing.create! :a => "a", :flex_a_input => "flex a", :b => "unrelated b"
+      thing.a.should == "flex a"
+    end
+
+    it "should not update the attribute if the virtual one is not present" do
+      thing = Thing.create! :a => "a"
+      thing.a.should == "a"
+    end
+  end
+
+  describe "using an :on option" do
+    it "should determine the calling time of the callback using the provided option" do
+      thing = Thing.new :b => "b", :flex_b_input => "flex b"
+
+      lambda do
+        thing.save
+      end.should change(thing, :b).from("b").to("flex b")
+    end
+  end
+
+  describe "with an :if option" do
+    it "should only update the attribute if the provided lambda returns true" do
+      thing = Thing.create! :c => "c", :flex_c_input => "1"
+      thing.c.should == "c"
+
+      thing = Thing.create! :c => "c", :flex_c_input => "2"
+      thing.c.should == "2"
+    end
+  end
+
+  describe "with a custom block" do
+    it "should use the custom block to update the attribute value" do
+      thing = Thing.create! :a => "a", :b => "b", :c => "c", :d => "d", :flex_d_input => "flex d"
+      thing.d.should == "a-b-c-flex d-flex d"
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'active_record'
+require 'flexselect'
+require 'spec'
+require 'spec/autorun'
+require 'active_record_helper'
+
+# Rails hook.
+require(File.join(File.dirname(__FILE__), '..', 'init.rb'))
+
+Spec::Runner.configure do |config|
+end

data/tasks/flexselect_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :flexselect do
+#   # Task goes here
+# end

data/uninstall.rb

@@ -0,0 +1,2 @@
+# Uninstall hook code here
+puts "Goodbye."

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: flexselect
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
+platform: ruby
+authors: 
+- Emmanuel Oga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-07 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: yard
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: For rails applications, requires jQuery
+email: EmmanuelOga@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- generators/flexselect/USAGE
+- generators/flexselect/flexselect_generator.rb
+- generators/flexselect/templates/flexselect.css
+- generators/flexselect/templates/jquery.flexselect.js
+- generators/flexselect/templates/liquidmetal.js
+- install.rb
+- lib/flexselect.rb
+- rails/init.rb
+- spec/active_record_helper.rb
+- spec/flexselect_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/flexselect_tasks.rake
+- uninstall.rb
+has_rdoc: true
+homepage: http://github.com/EmmanuelOga/flexselect
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A jQuery plugin and an activerecord extension to provide auto-complete on html select tags
+test_files: 
+- spec/spec_helper.rb
+- spec/flexselect_spec.rb
+- spec/active_record_helper.rb