lucid_works 0.6.29 → 0.7.1

data/lib/lucid_works/gem_version.rb

@@ -1,3 +1,3 @@
 module LucidWorks
-  VERSION = "0.6.29"
+  VERSION = "0.7.1"
 end

data/lib/lucid_works/jdbcdriver.rb

@@ -0,0 +1,30 @@
+module LucidWorks
+
+  # This model is a strange beast.
+  # You can DELETE it, but that's about it.
+  # GET on the plural resource name returns a list of strings, not hashes
+  # so we create these things by hand in Collection
+  class Jdbcdriver < Base
+    belongs_to :collection
+
+    schema do
+      primary_key :name
+      attribute :name
+      attribute :file
+    end
+
+    validates_presence_of :name
+
+    # Dont' let LucidWorks::Base do this as it will try to encode us as JSON
+    # In this case we need to let RestClient do it's thing and figure out we should do a multipart post
+    def save
+      return false unless valid?
+      RestClient.post(collection_url, :file => file)
+      @persisted = true
+    rescue RestClient::Exception => e
+      @persisted = false
+      attach_errors_to_model(e.response)
+      return false
+    end
+  end
+end

data/lib/lucid_works/role.rb

@@ -0,0 +1,59 @@
+module LucidWorks
+  class Role < Base
+    belongs_to :collection
+
+    schema do
+      attribute :name, :string, :primary_key => true, :omit_during_update => true
+      attribute :users, :custom
+      attribute :groups#, :custom
+      attribute :filters#, :custom
+    end
+    
+    def users
+      @attributes[:users]
+    end
+    
+    def groups
+      @attributes[:groups]
+    end
+    
+    def filters
+      # require 'ruby-debug'; debugger
+      @attributes[:filters]
+    end
+    
+    def filters_for_text_area
+      @attributes[:filters].join("\n")
+    end
+    
+    #
+    # Accept a comma or space separated list of users, convert to array
+    #
+    def users=(val)
+      @attributes[:users] = string_or_array(val, /[\s,]+/) rescue "Can't interpret #{val.class} as list of users"
+    end
+    
+    def groups=(val)
+      @attributes[:groups] = string_or_array(val, /[\s,]+/) rescue "Can't interpret #{val.class} as list of groups"
+    end
+    
+    def filters=(val)
+      @attributes[:filters] = string_or_array(val, /\r+/) rescue "Can't interpret #{val.class} as list of groups"
+      # require 'ruby-debug'; debugger
+      # @attributes[:filters]
+    end
+      
+    private
+    
+    def string_or_array(val, pattern)
+      if val.is_a?(String)
+        val.split(pattern)
+      elsif val.is_a?(Array)
+        val
+      else
+        raise "Don't know how to convert #{val.class} to Array"
+      end
+      
+    end
+  end
+end

data/lib/lucid_works/schema/attribute.rb

@@ -0,0 +1,86 @@
+module LucidWorks
+  class Schema
+
+    class Attribute
+      ATTRIBUTES_TYPES = [ :string, :integer, :boolean, :iso8601, :custom ]
+      RESERVED_ATTRIBUTE_NAMES = %{ class nil? send caller object_id }
+
+      attr_reader :schema, :name, :values, :origin
+
+      class << self
+
+        def factory(schema, name, type, options={})
+          raise "Unknown attribute type: #{type.inspect}" unless ATTRIBUTES_TYPES.include?(type)
+          attribute_class = ( "LucidWorks::Schema::" + ("#{type}_attribute".classify) ).constantize
+          attribute_class.new(schema, name, options)
+        end
+
+        # Change any characters illegal for an identifier to _
+        def sanitize_name(identifier) # :nodoc:
+          sane_identifier = identifier.to_s.gsub(/[^\w]/, '_')
+          sane_identifier = "_#{sane_identifier}" if RESERVED_ATTRIBUTE_NAMES.include?(sane_identifier)
+          sane_identifier.to_sym
+        end
+      end
+
+      def initialize(schema, name, options={})
+        @schema = schema
+        @true_name = name.to_s                  # External representation. Will be used when sending data back to REST API
+        @name = self.class.sanitize_name(name)  # Internal representation. A symbol.
+        @origin = options[:origin]
+        @omit_during_update = options[:omit_during_update]
+        @omit_when_blank = options[:omit_when_blank]
+        @nil_when_blank = options[:nil_when_blank]
+        @values = options[:values]
+      end
+
+      def type
+        raise "type() method must be implemented by Attribute subclass"
+      end
+
+      def omit_during_update? ; @omit_during_update end
+      def omit_when_blank?    ; @omit_when_blank    end
+      def nil_when_blank?     ; @nil_when_blank     end
+      
+      def create_accessors_for_attribute(klass) # :nodoc:
+        klass.class_eval <<-EOF, __FILE__, __LINE__+1
+          def #{name}                                     # def foo
+            @attributes[:#{name}]                         #   @attributes[:foo]
+          end                                             # end
+        EOF
+      end
+
+      def encode_and_insert(value, hash, is_update) # :nodoc:
+        return if omit_during_update? && is_update
+        return if omit_when_blank? && (value.nil? || value == "")
+        hash[@true_name.to_s] = encode(value)
+      end
+
+      def human_value(value)
+        if values
+          # If this attribute was defined with a set of :values,
+          # assume we can get translations for those valuesfrom the L10n database.
+          l10n_scope = %w{activemodel models} + schema.model.name.underscore.split('/') + [name]
+          return I18n.t(value, :scope => l10n_scope, :default => value)
+        end
+        value.to_s
+
+      rescue
+        value.to_s
+      end
+
+      def to_select
+        raise "Can't to_select for attribute #{name} as it has no values" unless values
+        values.map do |value|
+          [human_value(value), value]
+        end
+      end
+
+      private
+
+      def encode(value)
+        value
+      end
+    end
+  end
+end

data/lib/lucid_works/schema/boolean_attribute.rb

@@ -0,0 +1,34 @@
+module LucidWorks
+  class Schema
+
+    class BooleanAttribute < Attribute
+
+      def type
+        :boolean
+      end
+
+      def create_accessors_for_attribute(klass) # :nodoc:
+        super
+
+        klass.class_eval <<-EOF, __FILE__, __LINE__+1
+          def #{name}?                                            # def foo?
+            @attributes[:#{name}]                                 #   @attributes[:foo]
+          end                                                     # end
+
+          def #{name}=(new_value)                                 # def foo=(new_value)
+            begin                                                 #   begin
+              @attributes[:#{name}] = to_bool(new_value)          #     @attributes[:foo] = to_bool(new_value)
+            rescue                                                #   rescue
+              raise "Expected #{name} to take a boolean"+         #     raise "Expected <some_bool> to take a boolean
+                    " value, but '\#\{new_value}' is ambiguous"   #           " value, but 'frozbot' is ambiguous"
+            end                                                   #   end
+          end                                                     # end
+        EOF
+      end
+
+      def human_value(value)
+        value.to_yesno
+      end
+    end
+  end
+end

data/lib/lucid_works/schema/custom_attribute.rb

@@ -0,0 +1,15 @@
+module LucidWorks
+  class Schema
+
+    class CustomAttribute < Attribute
+
+      def type
+        :custom
+      end
+
+      def create_accessors_for_attribute(klass) # :nodoc:
+        # Do nothing.  Developer will provide own accessors.
+      end
+    end
+  end
+end

data/lib/lucid_works/schema/integer_attribute.rb

@@ -0,0 +1,32 @@
+module LucidWorks
+  class Schema
+
+    class IntegerAttribute < Attribute
+      include ActionView::Helpers::NumberHelper rescue nil
+
+      def type
+        :integer
+      end
+
+      def create_accessors_for_attribute(klass) # :nodoc:
+        super
+
+        klass.class_eval <<-EOF, __FILE__, __LINE__+1
+          def #{name}=(new_value)
+            if new_value.blank? && (self.class.schema[:#{name}].nil_when_blank? ||
+                                    self.class.schema[:#{name}].omit_when_blank?)
+              new_value = nil
+            else
+              new_value = new_value.to_i
+            end
+            @attributes[:#{name}] = new_value
+          end
+        EOF
+      end
+
+      def human_value(value)
+        number_with_delimiter(value)
+      end
+    end
+  end
+end

data/lib/lucid_works/schema/iso8601_attribute.rb

@@ -0,0 +1,31 @@
+module LucidWorks
+  class Schema
+
+    class Iso8601Attribute < Attribute
+
+      def type
+        :iso8601
+      end
+
+      def create_accessors_for_attribute(klass) # :nodoc:
+        super
+
+        klass.class_eval <<-EOF, __FILE__, __LINE__+1
+          def #{name}=(new_value)
+            if new_value.kind_of?(String)
+              @attributes[:#{name}] = Time.iso8601(new_value)
+            else
+              @attributes[:#{name}] = new_value
+            end
+          end
+        EOF
+      end
+
+      private
+      
+      def encode(value)
+        value.iso8601 rescue value
+      end
+    end
+  end
+end

data/lib/lucid_works/schema/string_attribute.rb

@@ -0,0 +1,22 @@
+module LucidWorks
+  class Schema
+
+    class StringAttribute < Attribute
+
+      def type
+        :string
+      end
+
+      def create_accessors_for_attribute(klass) # :nodoc:
+        super
+        
+        klass.class_eval <<-EOF, __FILE__, __LINE__+1
+          def #{name}=(new_value)
+            new_value = nil if new_value.blank? && self.class.schema[:#{name}].nil_when_blank?
+            @attributes[:#{name}] = new_value
+          end
+        EOF
+      end
+    end
+  end
+end

data/lib/lucid_works/schema.rb

@@ -3,7 +3,8 @@ module LucidWorks
   # Schema is used to delare attributes for a model.
 
   class Schema < ActiveSupport::HashWithIndifferentAccess
-    ATTRIBUTES_TYPES = [ :string, :integer, :boolean, :iso8601, :custom ]
+
+    attr_reader :model
 
     # Initializes the schema, taking a block of schema declarations.
     # Typically it is called from LucidWorks::Base, e.g.:
@@ -22,11 +23,17 @@ module LucidWorks
     #     end
     #   end
     #
-    def initialize
+    def initialize(model)
+      @model = model
       @primary_key = :id
       @dynamic_attributes = true
     end
 
+    # If this model's primary key is something other than 'id',
+    # use the primary_key method it indicate that. e.g.
+    #
+    #   primary_key "name"
+
     def primary_key(key=nil)
       @primary_key = key.to_sym if key
       @primary_key
@@ -41,9 +48,62 @@ module LucidWorks
       @dynamic_attributes = !!on unless on.nil?
       @dynamic_attributes
     end
-    
+
     alias :dynamic_attributes? :dynamic_attributes
 
+    def has_attribute?(name)
+      has_key? Attribute.sanitize_name(name)
+    end
+
+    def find_or_create_attribute(name)
+      attrname = Attribute.sanitize_name(name)
+      attribute = fetch(attrname, nil)
+      unless attribute
+        if dynamic_attributes?
+          attribute = add_attribute(name, :string)
+        else
+          raise "unknown attribute: \"#{attr}\""
+        end
+      end
+      attribute
+    end
+
+    # Used for classes that have no predefined schema.
+    # When the class is retrieved.
+    def add_attribute(name, type=:string) # :nodoc:
+      raise "Class #{model.name} already has attribute #{name}" if has_attribute?(Attribute.sanitize_name(name))
+      attribute = Attribute.factory(self, name, type, :origin => :added_later)
+      attribute.create_accessors_for_attribute(model)
+      self[attribute.name] = attribute
+    end
+
+    # Create accessors for all attributes defined in the schema.
+    def create_accessors_for_attributes(klass) # :nodoc:
+      self.values.each do |attr|
+        attr.create_accessors_for_attribute(klass)
+      end
+    end
+
+    # Reset the schema to the originally defined version (before we added a bunch of attributes during load or create)
+    def reset!
+      each do |name, attr|
+        if attr.origin != :original
+          model.class_eval <<-EOF, __FILE__, __LINE__+1
+            undef_method(:#{name})
+            undef_method(:"#{name}=")
+          EOF
+          delete(name)
+        end
+      end
+    end
+
+    private
+
+    ###################################################################################################################
+    # The following are private methods, that will be accessed when LucidWorks::Base does an
+    # instance_eval in response to a schema(&block) call.
+    ###################################################################################################################
+
     # Declare a single attribute.
     #
     # Attributes may be of the following types:
@@ -66,9 +126,10 @@ module LucidWorks
     # [:omit_when_blank => true]    When this attribute is blank?, don't send it to the server during save.
 
     def attribute(name, type=:string, options={})
-      raise "Unknown attribute type: #{type.inspect}" unless ATTRIBUTES_TYPES.include?(type)
       primary_key name if options.delete(:primary_key)
-      self[name] = options.merge(:type => type)
+      options[:origin] = :original
+      attr = Attribute.factory(self, name, type, options)
+      self[attr.name] = attr
     end
 
     # Specify multiple attributes.  Options apply to all attributes, e.g.
@@ -85,97 +146,5 @@ module LucidWorks
         attribute name, type, options
       end
     end
-
-    def has_attribute?(name)
-      has_key? sanitize_identifier(name)
-    end
-
-    def attrs_to_omit_during_update
-      select { |k,v| v['omit_during_update'] == true }.keys
-    end
-
-    # Used for classes that have no predefined schema.
-    # When the class is retrieved.
-    def add_attribute(klass, name, type=:string) # :nodoc:
-      attr = sanitize_identifier(name)
-      raise "Class #{klass.name} already has attribute #{attr}" if has_attribute?(attr)
-      self[attr] = { :type => type }
-      create_attribute(klass, attr)
-    end
-
-    # Create accessors for all attributes defined in the schema.
-    def create_accessors_for_attributes(klass) # :nodoc:
-      self.keys.each do |attr|
-        create_attribute(klass, attr)
-      end
-    end
-
-    def create_attribute(klass, attribute) # :nodoc:
-      klass.class_eval <<-EOF, __FILE__, __LINE__+1
-        def #{attribute}                            # def foo
-          @attributes[:#{attribute}]                #   @attributes[:foo]
-        end                                         # end
-      EOF
-      
-      case self[attribute][:type]
-      when :boolean
-        klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{attribute}?                           # def foo?
-            @attributes[:#{attribute}]                #   @attributes[:foo]
-          end                                         # end
-
-          def #{attribute}=(new_value)                            # def foo=(new_value)
-            begin                                                 #   begin
-              @attributes[:#{attribute}] = to_bool(new_value)     #     @attributes[:foo] = to_bool(new_value)
-            rescue                                                #   rescue
-              raise "Expected #{attribute} to take a boolean"+    #     raise "Expected <some_bool> to take a boolean
-                    " value, but '\#\{new_value}' is ambiguous"     #           " value, but 'frozbot' is ambiguous"
-            end                                                   #   end
-          end                                                     # end
-        EOF
-      when :string
-        klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{attribute}=(new_value)                # def foo=(new_value)
-            new_value = nil if new_value.blank? && self.class.schema[:#{attribute}][:nil_when_blank]
-            @attributes[:#{attribute}] = new_value    #   @attributes[:foo] = new_value
-          end                                         # end
-        EOF
-      when :integer
-        klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{attribute}=(new_value)
-            if new_value.blank? && (self.class.schema[:#{attribute}][:nil_when_blank] ||
-                                    self.class.schema[:#{attribute}][:omit_when_blank])
-              new_value = nil
-            else
-              new_value = new_value.to_i
-            end
-            @attributes[:#{attribute}] = new_value
-          end
-        EOF
-      when :iso8601
-        klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{attribute}=(new_value)
-            if new_value.kind_of?(String)
-              @attributes[:#{attribute}] = Time.iso8601(new_value)
-            else
-              @attributes[:#{attribute}] = new_value
-            end
-          end
-        EOF
-      when :custom
-        # Do nothing.  Developer will provide own accessors.
-      else
-        klass.class_eval <<-EOF, __FILE__, __LINE__+1
-          def #{attribute}=(new_value)                # def foo=(new_value)
-            @attributes[:#{attribute}] = new_value    #   @attributes[:foo] = new_value
-          end                                         # end
-        EOF
-      end
-    end
-
-     # Change any characters illegal for an identifier to _
-    def sanitize_identifier(identifier) # :nodoc:
-      identifier.to_s.gsub(/[^\w]/, '_').to_sym
-    end
   end
 end