lucid_works 0.1.1

data/.autotest

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/.gitignore

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

data/.rspec

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@lucidworks

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in lucid_works.gemspec
+gemspec
+
+group :development do
+  gem 'ruby-debug19'
+  gem 'rspec'
+  gem 'autotest'
+  gem "autotest-fsevent"
+end

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc "Create RDoc documentation"
+task :doc do
+  system 'rdoc'
+end

data/lib/lucid_works.rb

@@ -0,0 +1,26 @@
+module LucidWorks
+end
+
+require 'active_model'
+require 'active_support/core_ext/module/attr_accessor_with_default'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/inflector'
+require 'restclient'
+require 'json'
+
+require 'lucid_works/patch_restclient'
+
+require 'lucid_works/exceptions'
+require 'lucid_works/associations'
+require 'lucid_works/server'
+require 'lucid_works/base'
+
+require 'lucid_works/collection'
+require 'lucid_works/collection/info'
+require 'lucid_works/collection/index'
+require 'lucid_works/collection/settings'
+require 'lucid_works/datasource'
+require 'lucid_works/datasource/index'
+require 'lucid_works/datasource/status'
+require 'lucid_works/datasource/history'
+require 'lucid_works/datasource/schedule'

data/lib/lucid_works/associations.rb

@@ -0,0 +1,118 @@
+module LucidWorks
+
+  module Associations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Specifies a singleton child resource.
+      #
+      # In the parent resource creates methods:
+      #   child  - load and cache the child. Subsequent calls will access the cached value.
+      #   child! - load and cache the child, ignoring existing cached value if present.
+      #
+      # === Options
+      #
+      # The declaration can also include an options hash to specialize the behavior of the association.
+      #
+      # Options are:
+      # [:class_name]
+      #   Specify the class name of the association. Use it only if you want to us a child class name different
+      #   from the association name, e.g.
+      #     has_one :info, :class_name => :collection_info # use CollectionInfo class
+      #     has_one :foo,  :class_name => :'foo/bar'       # use Foo::Bar class
+      #
+      def has_one(*arguments)
+        options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+        arguments.each do |resource|
+          define_has_one resource, options
+        end
+      end
+
+      #
+      # Specifies a child resource.
+      #
+      # e.g. for Blog has_many posts
+      #
+      # In the parent resources creates methods:
+      #
+      #   posts
+      #   post(id)
+      #
+      def has_many(resources, options = {})
+        resource = resources.to_s.singularize
+        resource_class_name = (options[:class_name] || resource).to_s.classify
+
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{resources}(options={})
+            @#{resources} || #{resources}!
+          end
+
+          def #{resources}!(options={})
+            @#{resources} = #{resource_class_name}.all(options.merge :parent => self)
+          end
+
+          def #{resource}(id, options={})
+            #{resource_class_name}.find(id, options.merge(:parent => self))
+          end
+
+          def create_#{resource}(options = {})
+            #{resource_class_name}.create(options.merge :parent => self)
+          end
+
+          def build_#{resource}(options = {})
+            #{resource_class_name}.new(options.merge :parent => self)
+          end
+        EOF
+      end
+
+      # Specified a parent resource.
+      # In the child resource creates:
+      # e.g. for Post belongs_to Blog
+      #   Class methods:
+      #     parent_class => Blog
+      #
+      #   Instance methods:
+      #     blog
+      #
+      def belongs_to(parent_resource, options = {})
+        parent_resource_class_name = (options[:class_name] || parent_resource).to_s.classify
+
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def self.parent_class             # def self.parent_class
+            #{parent_resource_class_name}   #   Blog
+          end                               # end
+
+          def #{parent_resource}            # def blog
+            parent                          #  parent
+          end                               # end
+
+          private
+
+          def self.belongs_to_association_name
+            :'#{parent_resource}'
+          end
+        EOF
+      end
+
+      private
+
+      def define_has_one(resource, options={})
+        resource_class_name = (options[:class_name] || resource).to_s.camelize
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{resource}                                                # def resource
+            @#{resource} || #{resource}!                                 #   @resource || resource!
+          end                                                            # end
+
+          def #{resource}!                                               # def resource!
+            @#{resource} = #{resource_class_name}.find(:parent => self)  #   @resource = Resource.find(:parent => self)
+          end                                                            # end
+
+          def build_#{resource}(options = {})
+            #{resource_class_name}.new(options.merge :parent => self)
+          end
+        EOF
+      end
+    end
+  end
+end

data/lib/lucid_works/base.rb

@@ -0,0 +1,274 @@
+module LucidWorks
+
+  # LucidWorks::Base is our REST ORM foundation.
+  #
+  # The motivaiton for developing it was:
+  # * ActiveResource makes a lot of assumtions about how REST APIs should work that we had to keep patching it for
+  #   (e.g. parameters must always be nested inside :resouce => {}).
+  #
+  # * ActiveResource was missing some features we needed:
+  #   - send new id with POST
+  #   - associations
+  #   - multipart POST
+  #
+  # * The straw that broke the camel's back was the need to talk to the same type of REST API on multiple servers
+  #   simultaneously, which was so orthogonal to the design of ActiveResource that patching it to support this would
+  #   require a major re-write.
+  #
+  # So, I decided to marry ActiveModel and RestClient.
+  #
+  # Much of the internal structure here (method names etc) will resemble ActiveResource as I have spent much time
+  # wandering through that code.
+
+  class Base
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    include Associations
+
+    attr_accessor :parent           # :nodoc:
+    attr_writer   :id               # :nodoc:
+    attr_writer   :persisted        # :nodoc:
+    attr_accessor :raw_response     # :nodoc:
+    attr_accessor :response_data    # :nodoc:
+
+    class << self
+      attr_accessor_with_default :primary_key, :id
+      attr_accessor :collection_name
+      attr_accessor_with_default :singleton, false
+
+      def create(*arguments)
+        new(*arguments).tap { |model| model.save }
+      end
+
+      # Retrieve one or more models from the server.
+      #
+      # Find may be called in the following ways:
+      #
+      # Retrieve an entire collection:
+      #   find(:all, options)
+      #
+      # Retrieve a single model
+      #   find(id, options)
+      #   find(:one, id, options)
+      #
+      # Retrieve a singleton model
+      #   find(options)
+      #   find(:singleton, options)
+      #
+      # == Options
+      #
+      # :parent - mandatory, another LucidWorks::Base instance or a LucidWorks::Server instance.
+      #
+      def find(*arguments)
+        unless arguments.first.is_a?(Symbol)
+          # We weren't called with a symbol, figure out what kind of find this is and re-call
+          if singleton
+            raise ArgumentError.new("wrong number of arguments (#{arguments.size} for 1)") unless arguments.size == 1
+            return find(:singleton, *arguments)
+          else
+            raise ArgumentError.new("wrong number of arguments (#{arguments.size} for 2)") unless arguments.size == 2
+            return find(:one, *arguments)
+          end
+        end
+
+        kind_of_find = arguments.shift
+
+        if kind_of_find == :one
+          id = arguments.shift
+          options = arguments.shift
+          raise ArgumentError.new("find(:one) requires 3 arguments") if arguments.count > 0
+        else
+          options = arguments.first
+        end
+
+        parent = extract_parent_from_options(options)
+        includes = options.delete(:include)
+
+        url = case kind_of_find
+          when :all;       collection_url(parent)
+          when :one;       "#{parent.uri}/#{collection_name}/#{id}"
+          when :singleton; "#{parent.uri}/#{singleton_name}"
+        end
+
+        raw_response = RestClient.get(url)
+        data = JSON.parse(raw_response)
+
+        results =
+          if kind_of_find == :all
+            data.collect do |collection_attributes|
+              new(collection_attributes.merge(:parent => parent, :persisted => true))
+            end
+          else
+            attributes = data.is_a?(Hash) ? data : {}
+            attributes.merge!(:parent => parent, :persisted => true)
+            object = new(attributes)
+            object.raw_response = raw_response
+            object.response_data = data
+            object
+          end
+
+        # Process :include options
+        # Pedestrian version first: step through all results and pull in submodel
+        if includes
+          [results].flatten.each do |model|
+            [includes].flatten.each do |include|
+              model.send(include)
+            end
+          end
+        end
+
+        results
+      end
+
+      def all(options)
+        find(:all, options)
+      end
+
+      def first(options)
+        find(:all, options).first
+      end
+
+      def last(options)
+        find(:all, options).last
+      end
+
+      def collection_name # :nodoc:
+        @collection_name || name.underscore.gsub(/^.*\//, '').pluralize
+      end
+
+      def collection_url(parent) # :nodoc:
+        "#{parent.uri}/#{collection_name}"
+      end
+
+      def singleton_name # :nodoc:
+        name.underscore.gsub(/^.*\//, '')
+      end
+
+      def extract_parent_from_options(options) # :nodoc:
+        # When this resource belongs_to another, allow the other's name as a key instead of :parent
+        if respond_to?(:belongs_to_association_name) && options.has_key?(belongs_to_association_name)
+          parent = options.delete(belongs_to_association_name)
+        else
+          parent = options.delete(:parent)
+        end
+        raise ArgumentError.new("parent is a required option") unless parent
+        unless parent.is_a?(Base) || parent.is_a?(Server)
+          raise ArgumentError.new("parent must be a LucidWorks::Server or LucidWorks::Base")
+        end
+        parent
+      end
+
+    end # class methods
+
+    def initialize(options)
+      raise ArgumentError.new("new requires a Hash") unless options.is_a?(Hash)
+      @parent = self.class.extract_parent_from_options(options)
+      @persisted = options.delete(:persisted) || singleton? || false
+      @attributes = options.with_indifferent_access
+    end
+
+    def save
+      if valid?
+        begin
+          if persisted?
+            response = RestClient.put(member_url, encode, :content_type => :json)
+          else
+            response = RestClient.post(collection_url, encode, :content_type => :json)
+            @persisted = true
+          end
+          load_attributes_from_json_string(response)
+          true
+        rescue RestClient::UnprocessableEntity, RestClient::Conflict => e
+          attach_errors_to_model(e.response)
+          false
+        end
+      end
+    end
+    
+    def destroy(options={})
+      RestClient.delete(member_url, options)
+    end
+
+    def id # :nodoc:
+      @attributes[self.class.primary_key]
+    end
+
+    def id=(value) # :nodoc:
+      @attributes[self.class.primary_key] = value
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def method_missing(method_sym, *arguments) # :nodoc:
+      return super if method_sym == :to_ary
+      if method_sym.to_s =~ /^(\w+)=$/
+        return @attributes[$1] = arguments.first
+      elsif method_sym.to_s =~ /^(\w+)\?$/
+        attr = $1
+        predicate = true
+      else
+        attr = method_sym
+        predicate = false
+      end
+      raise "Unknown attribute: '#{attr}'" unless @attributes.has_key?(attr)
+      predicate ? !!@attributes[attr] : @attributes[attr]
+    end
+
+    def read_attribute_for_validation(key) # :nodoc:
+      @attributes[key]
+    end
+
+    def collection_url # :nodoc:
+      self.class.collection_url(parent)
+    end
+
+    def member_url # :nodoc:
+      if singleton?
+        "#{parent.uri}/#{self.class.singleton_name}"
+      else
+        "#{parent.uri}/#{collection_name}/#{self.id}"
+      end
+    end
+    
+    alias :uri :member_url
+
+    def inspect
+      "<#{self.class.name} " + @attributes.map { |k,v| "#{k}=#{v.inspect}" }.join(" ") + ">"
+    end
+
+    private
+
+    def singleton? # :nodoc:
+      self.class.singleton
+    end
+
+    def collection_name # :nodoc:
+      self.class.collection_name
+    end
+
+    def encode # :nodoc:
+      @attributes.reject { |k,v| k.to_s == 'id'}.to_json
+    end
+
+    def load_attributes_from_json_string(response) # :nodoc:
+      data = JSON.parse(response) rescue {}
+      data.each do |k,v|
+        @attributes[k] = v
+      end
+    end
+    
+    def attach_errors_to_model(response) # :nodoc:
+      data = JSON.parse(response) rescue nil
+      if data.is_a?(Hash) && data['errors']
+        data['errors'].each do |error|
+          key = error['key'].blank? ? 'base' : error['key']
+          self.errors.add(key, error['message'])
+        end
+      end
+    end
+  end
+end