lucid_works 0.1.1

data/lib/lucid_works/collection.rb

@@ -0,0 +1,14 @@
+module LucidWorks
+
+  class Collection < Base
+
+    self.primary_key = :name
+
+    has_many :datasources
+    has_one  :info, :settings, :index
+
+    def empty!
+      build_index.destroy(:params => {:key => 'iaccepttherisk'})
+    end
+  end
+end

data/lib/lucid_works/collection/index.rb

@@ -0,0 +1,9 @@
+module LucidWorks
+  class Collection
+    
+    class Index < Base
+      self.singleton = true
+      belongs_to :collection
+    end
+  end
+end

data/lib/lucid_works/collection/info.rb

@@ -0,0 +1,9 @@
+module LucidWorks
+  class Collection
+    
+    class Info < Base
+      self.singleton = true
+      belongs_to :collection
+    end
+  end
+end

data/lib/lucid_works/collection/settings.rb

@@ -0,0 +1,9 @@
+module LucidWorks
+  class Collection
+    
+    class Settings < Base
+      self.singleton = true
+      belongs_to :collection
+    end
+  end
+end

data/lib/lucid_works/datasource.rb

@@ -0,0 +1,40 @@
+module LucidWorks
+  
+  class Datasource < Base
+    belongs_to :collection
+    has_many   :histories, :class_name => :history
+    has_one    :status, :history, :schedule, :index
+
+    TYPES = {
+      :FileSystemDataSource => {
+        :name_l10n_key => 'data_source.short_type.filesystem',
+        :crawler       => 'lucid.aperture',
+        :type          => 'file'
+      },
+      :WebDataSource => {
+        :name_l10n_key => 'data_source.short_type.web_site',
+        :crawler       => 'lucid.aperture',
+        :type          => 'web'
+      },
+      :SolrXmlDataSource => {
+        :name_l10n_key => 'data_source.short_type.solr',
+        :crawler       => 'lucid.solrxml',
+        :type          => 'solrxml'
+      },
+      :JDBCDataSource => {
+        :name_l10n_key => 'data_source.short_type.database',
+        :crawler       => 'lucid.jdbc',
+        :type          => 'jdbc'
+      },
+      :SharePointDataSource => {
+        :name_l10n_key => 'data_source.short_type.sharepoint',
+        :crawler       => 'lucid.gcm',
+        :type          => 'sharepoint'
+      }
+    }.with_indifferent_access
+
+    def empty!
+      build_index.destroy
+    end
+  end
+end

data/lib/lucid_works/datasource/history.rb

@@ -0,0 +1,17 @@
+module LucidWorks
+  class Datasource
+
+    class History < Base
+      belongs_to :datasource
+      self.collection_name = 'history' # i.e. not the plural 'histories'
+
+      def doc_count
+        numUpdated + numNew + numUnchanged
+      end
+
+      def elapsed_time
+        crawlStopped.to_datetime - crawlStarted.to_datetime
+      end
+    end
+  end
+end

data/lib/lucid_works/datasource/index.rb

@@ -0,0 +1,9 @@
+module LucidWorks
+  class Datasource
+
+    class Index < Base
+      self.singleton = true
+      belongs_to :datasource
+    end
+  end
+end

data/lib/lucid_works/datasource/schedule.rb

@@ -0,0 +1,9 @@
+module LucidWorks
+  class Datasource
+
+    class Schedule < Base
+      self.singleton = true
+      belongs_to :datasource
+    end
+  end
+end

data/lib/lucid_works/datasource/status.rb

@@ -0,0 +1,9 @@
+module LucidWorks
+  class Datasource
+
+    class Status < Base
+      self.singleton = true
+      belongs_to :datasource
+    end
+  end
+end

data/lib/lucid_works/exceptions.rb

@@ -0,0 +1,6 @@
+module LucidWorks
+  class Exception < ::StandardError
+  end
+
+  class ResourceNotFound < Exception ; end
+end

data/lib/lucid_works/patch_restclient.rb

@@ -0,0 +1,29 @@
+module RestClient
+  class Request
+
+    # Extract the query parameters for get request and append them to the url
+    def process_get_params url, headers
+      # LucidWorks: we also need params on a :delete
+      if [:get, :head, :delete].include? method
+      # if [:get, :head].include? method
+        get_params = {}
+        headers.delete_if do |key, value|
+          if 'params' == key.to_s.downcase && value.is_a?(Hash)
+            get_params.merge! value
+            true
+          else
+            false
+          end
+        end
+        unless get_params.empty?
+          query_string = get_params.collect { |k, v| "#{k.to_s}=#{CGI::escape(v.to_s)}" }.join('&')
+          url + "?#{query_string}"
+        else
+          url
+        end
+      else
+        url
+      end
+    end
+  end
+end

data/lib/lucid_works/server.rb

@@ -0,0 +1,23 @@
+module LucidWorks
+  #
+  # The LucidWorks::Server class is the starting point for access to a LucidWorks Solr search server.
+  #
+  class Server
+    include Associations
+
+    has_many :collections
+
+    DEFAULT_REST_API_PATH = "/api"
+
+    attr_accessor :host, :path
+
+    def initialize(server_uri, options = {})
+      @host = server_uri
+      @path = options.delete(:path) || DEFAULT_REST_API_PATH
+    end
+
+    def uri
+      @host + @path
+    end
+  end
+end

data/lib/lucid_works/version.rb

@@ -0,0 +1,3 @@
+module LucidWorks
+  VERSION = "0.1.1"
+end

data/lucid_works.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lucid_works/version"
+
+Gem::Specification.new do |s|
+  s.name        = "lucid_works"
+  s.version     = LucidWorks::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sam Pierson"]
+  s.email       = ["sam.pierson@lucidimagination.com"]
+  s.homepage    = ""
+  s.summary     = %q{Ruby wrapper for the LucidWorks REST API}
+  s.description = %q{Ruby wrapper for the LucidWorks REST API}
+
+  s.rubyforge_project = "lucid_works"
+
+  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"]
+
+  s.add_runtime_dependency 'activesupport', '>= 3'
+  s.add_runtime_dependency 'activemodel',   '>= 3'
+  s.add_runtime_dependency 'rest-client',   '>= 1.6.1'
+  s.add_runtime_dependency 'json'
+end

data/spec/lib/lucid_works/associations_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+describe LucidWorks::Associations do
+  before :all do
+    @fake_server_uri = "http://fakehost.com:8888"
+    @server = LucidWorks::Server.new(@fake_server_uri)
+
+    class ::Blog < LucidWorks::Base
+      has_many :posts
+      has_one :homepage
+    end
+    @blog = ::Blog.new(:parent => @server)
+
+    class ::Post < LucidWorks::Base
+      belongs_to :blog
+    end
+
+    class ::Homepage < LucidWorks::Base
+      self.singleton = true
+      belongs_to :blog
+    end
+  end
+
+  describe ".has_one" do
+    describe "#<child>!" do
+      it "should call Child.find" do
+        Homepage.should_receive(:find).with(:parent => @blog)
+        @blog.homepage!
+      end
+    end
+
+    describe "#<child>" do
+      it "should call child! the first time then return the cached value thereafter" do
+        mock_homepage = double('homepage')
+        Homepage.should_receive(:find).once.and_return(mock_homepage)
+        @blog.homepage.should == mock_homepage
+        @blog.homepage.should == mock_homepage
+      end
+    end
+
+    describe "#build_<child>" do
+      it "should create a new child with persisted = true" do
+        homepage = @blog.build_homepage
+        homepage.should be_a(Homepage)
+        homepage.should be_persisted
+      end
+    end
+  end
+
+  describe ".has_many" do
+    describe "#<children>!" do
+      it "should call Child.all" do
+        Post.should_receive(:all).with(:parent => @blog)
+        @blog.posts!
+      end
+    end
+
+    describe "#<children>" do
+      it "should call children! the first time then return the cached value thereafter" do
+        mock_posts = double('some posts')
+        Post.should_receive(:find).once.and_return(mock_posts)
+        @blog.posts.should == mock_posts
+        @blog.posts.should == mock_posts
+      end
+    end
+
+    describe "#<child>" do
+      it "should call Child.find" do
+        Post.should_receive(:find).with('child_id', :parent => @blog)
+        @blog.post('child_id')
+      end
+    end
+
+    describe "create_<child>" do
+      it "should call Child.create" do
+        Post.should_receive(:create).with(:name => 'child_name', :parent => @blog)
+        @blog.create_post(:name => 'child_name')
+      end
+    end
+
+    describe "#build_<child>" do
+      it "should create a new child with persisted = true" do
+        post = @blog.build_post
+        post.should be_a(Post)
+        post.should_not be_persisted
+      end
+    end
+  end
+
+  describe ".belongs_to" do
+
+    describe ".belongs_to_association_name (private)" do
+      it "should return the name of the association" do
+        Post.send(:belongs_to_association_name).should == :blog
+      end
+    end
+
+    describe ".parent_class" do
+      it "should return the parent class" do
+        Post.parent_class.should == Blog
+      end
+    end
+
+    describe "#initialize" do
+      it "should allow :<association_name> instead of :parent" do
+        lambda {
+          Post.new(:blog => @blog)
+        }.should_not raise_error
+      end
+    end
+
+    describe "#collection_url" do
+      it "should generate a url using its parents url and it's own name" do
+        @blog.id = 'fake_blog_id'
+        post = Post.new(:parent => @blog)
+        post.id = 'fake_post_id'
+        post.collection_url.should == "http://fakehost.com:8888/api/blogs/fake_blog_id/posts"
+      end
+    end
+
+    describe "#member_url" do
+      it "should generate a url using its parents url and it's own name and id" do
+        @blog.id = 'fake_blog_id'
+        post = Post.new(:parent => @blog)
+        post.id = 'fake_post_id'
+        post.send(:member_url).should == "http://fakehost.com:8888/api/blogs/fake_blog_id/posts/fake_post_id"
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/base_spec.rb

@@ -0,0 +1,399 @@
+require 'spec_helper'
+
+describe LucidWorks::Base do
+  before :all do
+    fake_server = "http://127.0.0.1:123456"
+    @server = LucidWorks::Server.new(fake_server)
+    @fake_server_uri = "#{fake_server}/api"
+
+    class Widget < LucidWorks::Base
+      has_one :singleton_widget
+    end
+    WIDGET1_JSON = '{"id":1,"name":"widget1","size":"small"}'
+    WIDGET2_JSON = '{"id":2,"name":"widget2","size":"medium"}'
+    WIDGETS_JSON = "[#{WIDGET1_JSON},#{WIDGET2_JSON}]"
+
+    class SingletonWidget < LucidWorks::Base
+      self.singleton = true
+    end
+  end
+
+  describe "class methods" do
+    describe ".new" do
+      it "should require a hash argument" do
+        lambda {
+          Widget.new(@server)
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise if not supplied with a server or parent" do
+        lambda {
+          Widget.new({})
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should raise if the provided parent is not a LucidWorks::Server or LucidWorks::Base" do
+        lambda {
+          Widget.new(:parent => "bogoserver")
+        }.should raise_error(ArgumentError)
+
+        lambda {
+          @parent = Widget.new(:parent => @server)
+        }.should_not raise_error
+
+        lambda {
+          Widget.new(:parent => @parent)
+        }.should_not raise_error
+      end
+
+      it "should raise if the provided parent is not a LucidWorks::Base" do
+        lambda {
+          Widget.new(:parent => "bogoparent")
+        }.should raise_error(ArgumentError)
+      end
+
+      it "should save the parent" do
+        widget = Widget.new(:parent => @server)
+        widget.parent.should == @server
+      end
+
+      it "should save all its attributes" do
+        widget = Widget.new(:name => 'fake_name', :size => 'fake_size', :parent => @server)
+        widget.name.should == 'fake_name'
+        widget.size.should == 'fake_size'
+      end
+
+      it "should default persisted to false" do
+        widget = Widget.new(:parent => @server)
+        widget.should_not be_persisted
+      end
+
+      it "should save persisted if provided" do
+        widget = Widget.new(:persisted => true, :parent => @server)
+        widget.should be_persisted
+      end
+
+      context "for a singleton" do
+        it "should always set singleton" do
+          widget = SingletonWidget.new(:parent => @server)
+          widget.should be_persisted
+        end
+      end
+    end
+
+    describe ".create" do
+      it "should call new and save" do
+        mock_widget = double('a mock widget')
+        Widget.should_receive(:new).with('fake_args').and_return(mock_widget)
+        mock_widget.should_receive(:save)
+        Widget.create('fake_args')
+      end
+    end
+
+    describe ".find" do
+      context ":all" do
+        it "should call RestClient.get with the appropriate URL and parse the response into models" do
+          correct_url = "#{@fake_server_uri}/widgets"
+          RestClient.should_receive(:get).with(correct_url).and_return(WIDGETS_JSON)
+
+          widgets = Widget.find(:all, :parent => @server)
+          widgets.size.should == 2
+
+          widget1 = widgets.find { |c| c.id == 1 }
+          widget1.should be_a(Widget)
+          widget1.name.should == 'widget1'
+          widget1.size.should == 'small'
+
+          widget2 = widgets.find { |c| c.id == 2 }
+          widget2.should be_a(Widget)
+          widget2.name.should == 'widget2'
+          widget2.size.should == 'medium'
+        end
+      end
+
+      context ":one" do
+        it "should call RestClient.get with the appropriate URL and parse the response into a model" do
+          correct_url = "#{@fake_server_uri}/widgets/1"
+          RestClient.should_receive(:get).with(correct_url).and_return(WIDGET1_JSON)
+
+          widget = Widget.find(:one, 1, :parent => @server)
+          widget.should be_a(Widget)
+          widget.name.should == 'widget1'
+          widget.size.should == 'small'
+        end
+      end
+
+      context ":singleton" do
+        it "should call RestClient.get with the appropriate URL and parse the response into a model" do
+          correct_url = "#{@fake_server_uri}/singleton_widget"
+          RestClient.should_receive(:get).with(correct_url).and_return(WIDGET1_JSON)
+
+          widget = SingletonWidget.find(:singleton, :parent => @server)
+          widget.should be_a(SingletonWidget)
+          widget.name.should == 'widget1'
+          widget.size.should == 'small'
+        end
+      end
+
+      describe ":include option" do
+        context "with a single argument" do
+          it "should retrieve the :included submodel" do
+            RestClient.should_receive(:get).with("#{@fake_server_uri}/widgets").and_return(WIDGETS_JSON)
+            mock_singleton1 = double('singleton widget1')
+            mock_singleton2 = double('singleton widget2')
+            SingletonWidget.should_receive(:find).and_return(mock_singleton1, mock_singleton2)
+
+            widgets = Widget.find(:all, :include => :singleton_widget, :parent => @server)
+
+            widgets.first.singleton_widget.should == mock_singleton1
+            widgets.last.singleton_widget.should == mock_singleton2
+          end
+        end
+
+        context "with a list of submodels" do
+          before :all do
+            # Give widget a second submodel
+            class Widget < LucidWorks::Base ; has_many :other_widgets ; end
+            class OtherWidget < LucidWorks::Base ; belongs_to :widget ; end
+          end
+
+          it "should retrieve all the :included submodels" do
+            RestClient.should_receive(:get).with("#{@fake_server_uri}/widgets").and_return(WIDGETS_JSON)
+            mock_singleton1 = double('singleton widget1')
+            mock_singleton2 = double('singleton widget2')
+            mock_other_widgets_1 = double('other widgets 1')
+            mock_other_widgets_2 = double('other widgets 2')
+            SingletonWidget.should_receive(:find).and_return(mock_singleton1, mock_singleton2)
+            OtherWidget.should_receive(:find).and_return(mock_other_widgets_1, mock_other_widgets_2)
+
+            widgets = Widget.find(:all, :include => [:singleton_widget, :other_widgets], :parent => @server)
+
+            widgets.first.singleton_widget.should == mock_singleton1
+            widgets.first.other_widgets.should == mock_other_widgets_1
+            widgets.last.singleton_widget.should == mock_singleton2
+            widgets.last.other_widgets.should == mock_other_widgets_2
+          end
+        end
+      end
+    end
+
+    describe ".all" do
+      it "should call find(:all)" do
+        Widget.should_receive(:find).with(:all, :parent => @server).and_return([])
+
+        Widget.all(:parent => @server)
+      end
+    end
+
+    describe ".first" do
+      it "should call find(:all) and return the first" do
+        mock_coll1 = double("collection 1")
+        mock_coll2 = double("collection 2")
+        Widget.should_receive(:find).with(:all, :parent => @server).and_return([mock_coll1, mock_coll2])
+
+        Widget.first(:parent => @server).should == mock_coll1
+      end
+    end
+  end
+
+  describe "instance methods" do
+
+    describe "collection_url" do
+      it "should generate a url from the server and its name" do
+        widget = Widget.new(:parent => @server, :id => 1234)
+        widget.collection_url.should == "#{@fake_server_uri}/widgets"
+      end
+    end
+
+    describe "member_url" do
+      it "should generate a url from the server, its name and its id" do
+        widget = Widget.new(:parent => @server, :id => 1234)
+        widget.member_url.should == "#{@fake_server_uri}/widgets/1234"
+      end
+    end
+
+    describe "attributes" do
+      before { @widget = Widget.new(:known_attr => 'known_value', :nil_attr => nil, :parent => @server) }
+
+      describe '#attr=' do
+        context "for an unknown attr" do
+          it "should set an attribute" do
+            @widget.new_attr = "fake_value"
+            @widget.new_attr.should == 'fake_value'
+          end
+        end
+        context "for a known attr" do
+          it "should set an attribute" do
+            @widget.known_attr = "new_value"
+            @widget.known_attr.should == 'new_value'
+          end
+        end
+      end
+
+      describe "#attr" do
+        context "for an unknown attr" do
+          it "should raise an error" do
+            lambda {
+              @widget.bogus_attr
+            }.should raise_error("Unknown attribute: 'bogus_attr'")
+          end
+        end
+        context "for a known attr" do
+          it "should return the attr" do
+            @widget.known_attr.should == 'known_value'
+          end
+        end
+      end
+
+      describe "#attr?" do
+        context "for an unknown attr" do
+          it "should raise an error" do
+            lambda {
+              @widget.bogus_attr?
+            }.should raise_error("Unknown attribute: 'bogus_attr'")
+          end
+        end
+        context "for a known attr" do
+          it "should return true or false" do
+            @widget.known_attr?.should be_true
+            @widget.nil_attr?.should be_false
+          end
+        end
+      end
+    end
+
+    describe "#save" do
+      context "for a new model" do
+        context "with valid attributes" do
+          before do
+            @widget_attrs = { :name => 'widget3', :size => 'large' }
+            @widget = Widget.new @widget_attrs.merge(:parent => @server)
+          end
+
+          it "should post to the correct address" do
+            correct_url = "#{@fake_server_uri}/widgets"
+            expected_json = @widget_attrs.to_json
+            RestClient.should_receive(:post).with(correct_url, expected_json, :content_type => :json)
+            @widget.save
+          end
+
+          it "should set persisted" do
+            RestClient.should_receive(:post)
+            @widget.save
+            @widget.should be_persisted
+          end
+        end
+
+        context "with invalid attributes" do
+          before :all do
+            @widget_attrs = { :name => '', :size => ''}
+            ERROR_422_RESPONSE = '{"errors":[{"message":"name is a required key","key":"name"},{"message":"name must consist of only A-Z a-z 0-9 - _","key":"name"}],"http_status_name":"Unprocessable Entity","http_status_code":422}'
+            # ERROR_500_RESPONSE = '{"errors":[{"message":"The server encountered an unexpected condition which prevented it from fulfilling the request","key":""}],"http_status_name":"Internal Server Error","http_status_code":500}'
+            RestClient.stub(:post) {
+              e = RestClient::UnprocessableEntity.new
+              e.response = ERROR_422_RESPONSE
+              raise e
+            }
+
+            @widget = Widget.new @widget_attrs.merge(:parent => @server)
+            @returncode = @widget.save
+          end
+
+          it "should set errors on the model" do
+            @widget.errors.should_not be_empty
+            @widget.errors['name'].should_not be_empty
+          end
+
+          it "should not set persisted" do
+            @widget.should_not be_persisted
+          end
+
+          it "should return false" do
+            @returncode.should be_false
+          end
+        end
+
+        describe "local validation" do
+          before do
+            class WidgetRequiringName < LucidWorks::Base
+              validates_presence_of :name
+            end
+          end
+
+          it "should validate presence of" do
+            widget = WidgetRequiringName.new(:parent => @server)
+            RestClient.should_not_receive(:post)
+            widget.should_not be_valid
+            widget.errors[:name].should == ["can't be blank"]
+            widget.save
+          end
+        end
+      end
+
+      context "for an existing model" do
+        it "should PUT to the correct address" do
+          @widget_attrs = { :name => 'widget3', :size => 'large' }
+          @widget = Widget.new @widget_attrs.merge(:parent => @server)
+          @widget.persisted = true
+          @widget.id = 1234
+          correct_url = "#{@fake_server_uri}/widgets/#{@widget.id}"
+          expected_json = @widget_attrs.to_json
+
+          RestClient.should_receive(:put).with(correct_url, expected_json, :content_type => :json)
+          @widget.save
+        end
+      end
+
+      context "for a singleton" do
+        before do
+          @widget_attrs = { :name => 'widget3', :size => 'large' }
+          @widget = SingletonWidget.new(@widget_attrs.merge :parent => @server, :persisted => true)
+        end
+
+        it "should put to the correct address" do
+          expected_json = @widget_attrs.to_json
+          correct_url = "#{@fake_server_uri}/singleton_widget"
+          RestClient.should_receive(:put).with(correct_url, expected_json, :content_type => :json)
+
+          @widget.save
+        end
+      end
+    end
+
+    describe "#destroy" do
+      it "should call RestClient.delete with the appropriate URL" do
+        widget = Widget.new(:parent => @server)
+        widget.id = 27
+        RestClient.should_receive(:delete).with("#{@fake_server_uri}/widgets/27", {})
+        widget.destroy
+      end
+    end
+  end
+
+  describe "for a model with primary key other than 'id'" do
+    before :all do
+      class NamedWidget < LucidWorks::Base
+        self.primary_key = :name
+      end
+      NAMED_WIDGET1_JSON = '{"name":"widget1","size":"small"}'
+      NAMED_WIDGET2_JSON = '{"name":"widget2","size":"medium"}'
+      NAMED_WIDGETS_JSON = "[#{WIDGET1_JSON},#{WIDGET2_JSON}]"
+    end
+
+    describe "#id" do
+      it "should return the primary key's value" do
+        w = NamedWidget.new(:name => 'fake_name', :parent => @server)
+        w.id.should == 'fake_name'
+      end
+    end
+    
+    describe "#id=" do
+      it "should set the primary key's value" do
+        w = NamedWidget.new(:name => 'fake_name', :parent => @server)
+        w.id = 'new_name'
+        w.id.should == 'new_name'
+        w.name.should == 'new_name'
+      end
+    end
+  end
+end