cheap_skate 0.0.1 → 0.0.2

data/bin/cheapskate

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+
+require File.dirname(__FILE__)+'/../lib/cheap_skate/cli'
+CheapSkate::CLI.new.run

data/conf/cheapskate.yml-dist

@@ -1,4 +1,4 @@
-:default
+:default:
     :prefix_path: /solr
     :ferret:
         :path: db/skate

data/lib/cheap_skate/application.rb

@@ -61,8 +61,8 @@ END
     end
 
     before do
-      if env[:prefix_path]
-        request.path_info.sub!(/^#{env[:prefix_path]}/,'')
+      if options.prefix_path
+        request.path_info.sub!(/^#{options.prefix_path}/,'')
       end
       unless request.path_info[-1,1] == "/"
         request.path_info << "/"

data/lib/cheap_skate/cli.rb

@@ -0,0 +1,48 @@
+require 'rake'
+require 'yaml'
+require 'fileutils'
+require File.dirname(__FILE__)+'/tasks'
+
+module CheapSkate
+  class CLI < Rake::Application
+    def initialize
+      super
+    end
+    def load_rakefile
+      @name = 'cheapskate'
+
+      # Load the main warbler tasks
+      CheapSkate::Task.new
+
+      task :default => :help
+
+      desc "Create a new CheapSkate instance"
+      task :init => "cheapskate:init"
+
+      desc "Convert a Solr schema.xml to CheapSkate schema.yml"
+      task :convertschema => "cheapskate:convertschema"
+
+    end
+
+    # Loads the project Rakefile in a separate application
+    def load_project_rakefile
+      Rake.application = Rake::Application.new
+      Rake::Application::DEFAULT_RAKEFILES.each do |rf|
+        if File.exist?(rf)
+          load rf
+          break
+        end
+      end
+      Rake.application = self
+    end
+
+    # Run the application: The equivalent code for the +warble+ command
+    # is simply <tt>Warbler::Application.new.run</tt>.
+    def run
+      Rake.application = self
+      super
+    end  
+  end
+
+end
+

data/lib/cheap_skate/index.rb

@@ -153,7 +153,7 @@ module CheapSkate
           bool.add_query(filtq, :must)
         else
           (idx, term) = fq.split(":")
-          term.sub!(/^\"/,'').sub!(/\"$/,'')
+          term = term.sub(/^\"/,'').sub(/\"$/,'')
           bool.add_query(Ferret::Search::TermQuery.new(idx.to_sym, term), :must)
         end
       end
@@ -169,7 +169,46 @@ module CheapSkate
     end
 
     def parse_morelikethis_query(params)
+      q = case params["q"].class.name
+      when "Array" then params["q"].first
+      when "String" then params["q"]
+      else "*:*"
+      end
+      opts = {}
+      opts[:limit] = 1
+      if params['mlt.match.offset']
+        opts[:offset] = [*params['mlt.match.offset']].first.to_i
+      end
+      mlt = nil
+      self.search_each(q, opts) do |doc, score|
+        mlt = self[doc].load
+      end
+      bool = Ferret::Search::BooleanQuery.new
+        unless params['mlt.match.include'] && [*params['mlt.match.include']].first == "true"
+          b = Ferret::Search::BooleanQuery.new
+          bool.add_query(Ferret::Search::TermQuery.new(:id, mlt[:id]), :must_not)
+        end      
+      mlt.each_pair do |key, val|
+
+        if val.is_a?(Array)
+          val.each do | v |
+            b = Ferret::Search::BooleanQuery.new
+            b.add_query(Ferret::Search::TermQuery.new(key, v))
+            bool << b
+          end
+        else
+          b = Ferret::Search::BooleanQuery.new
+          b.add_query(Ferret::Search::TermQuery.new(key, val))
+          bool << b
+        end
+      end
+      query = CheapSkate::Query.new
+      
+      # No idea why this is necessary, but Ferret will ignore our boolean NOT otherwise
+      p = Ferret::QueryParser.new      
+      query.query = p.parse(bool.to_s)
 
+      return query
     end
     
     def create_document(id=UUID.generate, boost=1.0)

data/lib/cheap_skate/models.rb

@@ -263,7 +263,7 @@ end
             next
           end
           if @fields[i] == "id"
-            doc[@index.schema.id_field] = field
+            doc[@index.schema.id_field] = field.strip
           else
             if @field_meta[@fields[i]] && @field_meta[@fields[i]]["split"] == "true"
               field.split(@field_meta[@fields[i]]["separator"]).each do |f|

data/lib/cheap_skate/schema.rb

@@ -1,227 +1,229 @@
 require 'rexml/document'
 require 'yaml'
-class CheapSkate::Schema
-  include CheapSkate
-  attr_reader :name, :fields, :config, :field_types, :id_field, :copy_fields, :dynamic_fields, :default_field, :default_operator
-  def self.xml_to_yaml(xml)
-    doc = REXML::Document.new xml
-    y = {"schema"=>{"types"=>{}, "fields"=>{}}}
-    y["schema"]["name"] = doc.root.attributes["name"]
-    y["schema"]["version"] = doc.root.attributes["version"]
-    doc.each_element("/schema/fields/field") do |field|
-      f = {}
-      field.attributes.each do |a,v|
-        next if a == "name"
-        f[a] = case v
-        when "true" then true
-        when "false" then false
-        else v
+module CheapSkate
+  class Schema
+    include CheapSkate
+    attr_reader :name, :fields, :config, :field_types, :id_field, :copy_fields, :dynamic_fields, :default_field, :default_operator
+    def self.xml_to_yaml(xml)
+      doc = REXML::Document.new xml
+      y = {"schema"=>{"types"=>{}, "fields"=>{}}}
+      y["schema"]["name"] = doc.root.attributes["name"]
+      y["schema"]["version"] = doc.root.attributes["version"]
+      doc.each_element("/schema/fields/field") do |field|
+        f = {}
+        field.attributes.each do |a,v|
+          next if a == "name"
+          f[a] = case v
+          when "true" then true
+          when "false" then false
+          else v
+          end
         end
+        y["schema"]["fields"][field.attributes['name']] = f
       end
-      y["schema"]["fields"][field.attributes['name']] = f
-    end
-    doc.each_element("/schema/fields/dynamicField") do |dyn_field|
-      f = {}
-      dyn_field.attributes.each do |a,v|
-        next if a == "name"
-        f[a] = case v
-        when "true" then true
-        when "false" then false
-        else v
+      doc.each_element("/schema/fields/dynamicField") do |dyn_field|
+        f = {}
+        dyn_field.attributes.each do |a,v|
+          next if a == "name"
+          f[a] = case v
+          when "true" then true
+          when "false" then false
+          else v
+          end
         end
-      end
-      y["schema"]["dynamic_fields"] ||= {}
-      y["schema"]["dynamic_fields"][dyn_field.attributes['name']] = f
-    end    
-    doc.each_element("/schema/types/fieldType") do |type|
-      t = {}
-      t[:type] = case type.attributes['class']
-      when "solr.StrField" then :string
-      when "solr.TextField" then :text
-      when "solr.IntField" then :int
-      when "solr.FloatField" then :float
-      when "solr.BoolField" then :bool
-      when "solr.DateField" then :date
-      end
-      if type.attributes['omitNorms'] &&  type.attributes['omitNorms'] == "true"
-        t[:index] = :omit_norms
-      end
-      unless t[:type] == :text
-        if t[:index] == :omit_norms
-          t[:index] = :untokenized_omit_norms
-        else
-          t[:index] = :untokenized
+        y["schema"]["dynamic_fields"] ||= {}
+        y["schema"]["dynamic_fields"][dyn_field.attributes['name']] = f
+      end    
+      doc.each_element("/schema/types/fieldType") do |type|
+        t = {}
+        t[:type] = case type.attributes['class']
+        when "solr.StrField" then :string
+        when "solr.TextField" then :text
+        when "solr.IntField" then :int
+        when "solr.FloatField" then :float
+        when "solr.BoolField" then :bool
+        when "solr.DateField" then :date
+        end
+        if type.attributes['omitNorms'] &&  type.attributes['omitNorms'] == "true"
+          t[:index] = :omit_norms
         end
+        unless t[:type] == :text
+          if t[:index] == :omit_norms
+            t[:index] = :untokenized_omit_norms
+          else
+            t[:index] = :untokenized
+          end
+        end
+        y["schema"]["types"][type.attributes['name']] = t
       end
-      y["schema"]["types"][type.attributes['name']] = t
-    end
-    doc.each_element("/schema/types/fieldtype") do |type|
-      t = {}
-      t[:type] = case type.attributes['class']
-      when "solr.StrField" then :string
-      when "solr.TextField" then :text
-      when "solr.IntField" then :int
-      when "solr.FloatField" then :float
-      when "solr.BoolField" then :bool
-      when "solr.DateField" then :date
+      doc.each_element("/schema/types/fieldtype") do |type|
+        t = {}
+        t[:type] = case type.attributes['class']
+        when "solr.StrField" then :string
+        when "solr.TextField" then :text
+        when "solr.IntField" then :int
+        when "solr.FloatField" then :float
+        when "solr.BoolField" then :bool
+        when "solr.DateField" then :date
+        end
+        if type.attributes['omitNorms'] &&  type.attributes['omitNorms'] == "true"
+          t[:index] = :omit_norms
+        end
+        unless t[:type] == :text
+          if t[:index] == :omit_norms
+            t[:index] = :untokenized_omit_norms
+          else
+            t[:index] = :untokenized
+          end
+        end
+        y["schema"]["types"][type.attributes['name']] = t
+      end  
+      if dflt = doc.elements['/schema/defaultSearchField']
+        y["schema"]["defaultSearchField"] = dflt.get_text.value if dflt.has_text?
       end
-      if type.attributes['omitNorms'] &&  type.attributes['omitNorms'] == "true"
-        t[:index] = :omit_norms
+      if uniq_key = doc.elements['/schema/uniqueKey']
+        y["schema"]["uniqueKey"] = uniq_key.get_text.value if uniq_key.has_text?
+      end    
+      copy_fields = []
+      doc.each_element("/schema/copyField") do |copy|
+        copy_fields << {copy.attributes['source']=>copy.attributes['dest']}
       end
-      unless t[:type] == :text
-        if t[:index] == :omit_norms
-          t[:index] = :untokenized_omit_norms
-        else
-          t[:index] = :untokenized
-        end
+      unless copy_fields.empty?
+        y["schema"]["copyFields"] = copy_fields
       end
-      y["schema"]["types"][type.attributes['name']] = t
-    end  
-    if dflt = doc.elements['/schema/defaultSearchField']
-      y["schema"]["defaultSearchField"] = dflt.get_text.value if dflt.has_text?
+      y.to_yaml
     end
-    if uniq_key = doc.elements['/schema/uniqueKey']
-      y["schema"]["uniqueKey"] = uniq_key.get_text.value if uniq_key.has_text?
-    end    
-    copy_fields = []
-    doc.each_element("/schema/copyField") do |copy|
-      copy_fields << {copy.attributes['source']=>copy.attributes['dest']}
-    end
-    unless copy_fields.empty?
-      y["schema"]["copyFields"] = copy_fields
-    end
-    y.to_yaml
-  end
   
-  def self.new_from_config(config_hash)
-    schema = self.new
-    schema.load_from_conf(config_hash)
-    schema
-  end
-  
-  def initialize
-    @copy_fields = {}
-  end
+    def self.new_from_config(config_hash)
+      schema = self.new
+      schema.load_from_conf(config_hash)
+      schema
+    end
   
-  def load_from_conf(conf)
-    @fields ={}
-    @field_types ={}
-    @name = conf['schema']['name']
-    conf['schema']['fields'].keys.each do |field|
-      @fields[field.to_sym] = {}
-      fld = conf['schema']['fields'][field]
-      @fields[field.to_sym][:field_type] = fld['type'].to_sym
-      if fld['indexed'] == false
-        @fields[field.to_sym][:index] = :no
-      end
-      if fld['stored'] == false
-        @fields[field.to_sym][:store] = :no
-      end  
-      @fields[field.to_sym][:multi_valued] = fld['multiValued']||false
+    def initialize
+      @copy_fields = {}
     end
-    if conf['schema']['dynamic_fields']
-      conf['schema']['dynamic_fields'].keys.each do |field|
-        @dynamic_fields ||= {}
-        @dynamic_fields[field.to_sym] = {}
-        fld = conf['schema']['dynamic_fields'][field]
-        @dynamic_fields[field.to_sym][:field_type] = fld['type'].to_sym
+  
+    def load_from_conf(conf)
+      @fields ={}
+      @field_types ={}
+      @name = conf['schema']['name']
+      conf['schema']['fields'].keys.each do |field|
+        @fields[field.to_sym] = {}
+        fld = conf['schema']['fields'][field]
+        @fields[field.to_sym][:field_type] = fld['type'].to_sym
         if fld['indexed'] == false
-          @dynamic_fields[field.to_sym][:index] = :no
+          @fields[field.to_sym][:index] = :no
         end
         if fld['stored'] == false
-          @dynamic_fields[field.to_sym][:store] = :no
+          @fields[field.to_sym][:store] = :no
+        end  
+        @fields[field.to_sym][:multi_valued] = fld['multiValued']||false
+      end
+      if conf['schema']['dynamic_fields']
+        conf['schema']['dynamic_fields'].keys.each do |field|
+          @dynamic_fields ||= {}
+          @dynamic_fields[field.to_sym] = {}
+          fld = conf['schema']['dynamic_fields'][field]
+          @dynamic_fields[field.to_sym][:field_type] = fld['type'].to_sym
+          if fld['indexed'] == false
+            @dynamic_fields[field.to_sym][:index] = :no
+          end
+          if fld['stored'] == false
+            @dynamic_fields[field.to_sym][:store] = :no
+          end  
+          @dynamic_fields[field.to_sym][:multi_valued] = fld['multiValued']||false
         end  
-        @dynamic_fields[field.to_sym][:multi_valued] = fld['multiValued']||false
       end  
-    end  
-    conf['schema']['types'].keys.each do |type|
-      @field_types[type.to_sym] = conf['schema']['types'][type]
-    end
-    conf['schema']['copyFields'].each do |copy|
-      copy.each_pair do | orig, dest|
-        @copy_fields[orig.to_sym] ||= []
-        @copy_fields[orig.to_sym] << dest.to_sym
+      conf['schema']['types'].keys.each do |type|
+        @field_types[type.to_sym] = conf['schema']['types'][type]
       end
+      conf['schema']['copyFields'].each do |copy|
+        copy.each_pair do | orig, dest|
+          @copy_fields[orig.to_sym] ||= []
+          @copy_fields[orig.to_sym] << dest.to_sym
+        end
+      end
+      @id_field = (conf['schema']['uniqueKey'] || "id").to_sym
+      @default_field = (conf['schema']['defaultSearchField']||"*").to_sym
+      @default_operator = (conf['schema']['defaultOperator']||"OR")   
     end
-    @id_field = (conf['schema']['uniqueKey'] || "id").to_sym
-    @default_field = (conf['schema']['defaultSearchField']||"*").to_sym
-    @default_operator = (conf['schema']['defaultOperator']||"OR")   
-  end
   
-  def typed_document(lazy_doc)
-    doc = {}
-    lazy_doc.fields.each do |field|
-      [*lazy_doc[field]].each do |fld|
-        if doc[field]
-          doc[field] = [*doc[field]]
-          doc[field] << type_field(field, fld)
-        elsif multi_valued?(field)
-          doc[field] = [type_field(field, fld)]
-        else
-          doc[field] = type_field(field, fld)
+    def typed_document(lazy_doc)
+      doc = {}
+      lazy_doc.fields.each do |field|
+        [*lazy_doc[field]].each do |fld|
+          if doc[field]
+            doc[field] = [*doc[field]]
+            doc[field] << type_field(field, fld)
+          elsif multi_valued?(field)
+            doc[field] = [type_field(field, fld)]
+          else
+            doc[field] = type_field(field, fld)
+          end
         end
       end
+      doc    
     end
-    doc    
-  end
   
-  def multi_valued?(field)
-    if @fields[field]
-      return @fields[field][:multi_valued]
-    else
-      dyn_field = nil
-      @dynamic_fields.keys.each do |dyn|
-        if dyn =~ /^\*/
-          r = Regexp.new(dyn.sub(/^\*/,".*"))
-        elsif dyn =~ /\*$/
-          r = Regexp.new(dyn.sub(/\*$/,".*"))
+    def multi_valued?(field)
+      if @fields[field]
+        return @fields[field][:multi_valued]
+      else
+        dyn_field = nil
+        @dynamic_fields.keys.each do |dyn|
+          if dyn =~ /^\*/
+            r = Regexp.new(dyn.sub(/^\*/,".*"))
+          elsif dyn =~ /\*$/
+            r = Regexp.new(dyn.sub(/\*$/,".*"))
+          end
+          if field =~ dyn
+            dyn_field = dyn
+            break
+          end        
         end
-        if field =~ dyn
-          dyn_field = dyn
-          break
-        end        
+        return dyn_field[:multi_valued] if dyn_field        
       end
-      return dyn_field[:multi_valued] if dyn_field        
+      false
     end
-    false
-  end
   
-  def type_field(field_name, value)
-    return value.to_s unless @fields[field_name]
-    val = case @field_types[@fields[field_name][:field_type]][:type]
-    when :string then value.to_s
-    when :text then value.to_s
-    when :int then value.to_i
-    when :float then value.to_f
-    when :date then Date.parse(value)
-    when :bool
-      if value == "true"
-        true
+    def type_field(field_name, value)
+      return value.to_s unless @fields[field_name]
+      val = case @field_types[@fields[field_name][:field_type]][:type]
+      when :string then value.to_s
+      when :text then value.to_s
+      when :int then value.to_i
+      when :float then value.to_f
+      when :date then Date.parse(value)
+      when :bool
+        if value == "true"
+          true
+        else
+          false
+        end
       else
-        false
+        val.to_s
       end
-    else
-      val.to_s
+      val
     end
-    val
-  end
-  
-  def field_names
-    return @fields.keys
-  end
   
-  def field_to_field_info(field_name)
-    opts = {}
-    if @fields[field_name][:index] == :no
-      opts[:index] = :no
-      opts[:term_vector] = :no
-    elsif @field_types[@fields[field_name][:field_type]][:index]
-      opts[:index] = @field_types[@fields[field_name][:field_type]][:index]
+    def field_names
+      return @fields.keys
     end
-    if @fields[field_name][:stored] == :no
-      opts[:store] = :no
+  
+    def field_to_field_info(field_name)
+      opts = {}
+      if @fields[field_name][:index] == :no
+        opts[:index] = :no
+        opts[:term_vector] = :no
+      elsif @field_types[@fields[field_name][:field_type]][:index]
+        opts[:index] = @field_types[@fields[field_name][:field_type]][:index]
+      end
+      if @fields[field_name][:stored] == :no
+        opts[:store] = :no
+      end
+      Ferret::Index::FieldInfo.new(field_name, opts)
     end
-    Ferret::Index::FieldInfo.new(field_name, opts)
-  end
   
+  end
 end

data/lib/cheap_skate/tasks.rb

@@ -0,0 +1,123 @@
+require 'rake/tasklib'
+require File.dirname(__FILE__)+'/schema'
+module CheapSkate
+  class Task < Rake::TaskLib
+    attr_accessor :name
+    def initialize(name = :cheapskate)
+      @name = name
+
+      yield self if block_given?
+      define_tasks
+    end    
+
+    private
+    def define_tasks
+      define_help_task
+      namespace name do
+        define_init_task
+        define_convertschema_task
+      end
+    end  
+    
+    def define_help_task
+      desc "Explains the available commands"
+      task "help" do
+        puts "Available commands:\n\n"
+        puts "\tcheapskate init [project_name] # creates a new CheapSkate instance"
+        puts "\tcheapskate convertschema xml=/path/to/schema.xml {yaml=/path/to/output/schema.yml} # converts a schema.xml to schema.yml"
+      end
+    end  
+    
+    def define_init_task
+
+      task :init do |t|
+        args = ARGV
+        raise ArgumentError, "Must supply an project name.  Usage: cheapskate init {project_name}" if args.length < 2
+        raise ArgumentError, "Too many arguments supplied.  Usage: cheapskate init {project_name}" if args.length > 2
+        raise ArgumentError, "First argument was not 'init' -- how did we get here?!" unless args.first == 'init'
+        cwd = Dir.getwd
+        project = args[1]
+        puts "Create new CheapSkate in #{cwd}/#{project}?  [y/N]"
+        STDOUT.flush
+        input = STDIN.gets
+        input.chomp!
+        input = "N" if input !~ /^y$/i
+        if input == "N"
+          puts "Exiting."
+          exit
+        else
+          if exists = File.exists?("#{cwd}/#{project}")
+            puts "A directory already exists at #{cwd}/#{project}!\nExiting."
+            exit
+          else
+            puts "Creating CheapSkate root: #{cwd}/#{project}"
+            root = FileUtils.mkdir("#{cwd}/#{project}")
+            puts "Creating configuration directory: #{cwd}/#{project}/conf"
+            conf = FileUtils.mkdir("#{cwd}/#{project}/conf")
+            puts "Creating directory for the Ferret index: #{cwd}/#{project}/db"
+            db = FileUtils.mkdir("#{cwd}/#{project}/db")    
+            puts "Creating log directory: #{cwd}/#{project}/log"
+            db = FileUtils.mkdir("#{cwd}/#{project}/log")
+            puts "Creating public directory: #{cwd}/#{project}/public"
+            db = FileUtils.mkdir("#{cwd}/#{project}/public")    
+            config = {project.to_sym=>{:ferret=>{:path=>"db/skate"}, :facet_score_threshold=>0.0, :schema=>"conf/schema.yml"}}
+            puts "Writing default cheapskate.yml"
+            cs_yml = open("#{cwd}/#{project}/conf/cheapskate.yml", "w")
+            cs_yml << config.to_yaml
+            cs_yml.close
+            schema = {"schema"=>{"name"=>"example", "copyFields"=>[{"cat"=>"text"}, {"name"=>"text"}, {"manu"=>"text"}, {"features"=>"text"}, {"includes"=>"text"}, {"manu"=>"manu_exact"}], "fields"=>{"name"=>{"stored"=>true, "indexed"=>true, "type"=>"textgen"}, "cat"=>{"stored"=>true, "multiValued"=>true, "indexed"=>true, "type"=>"text_ws", "omitNorms"=>true}, "price"=>{"stored"=>true, "indexed"=>true, "type"=>"float"}, "popularity"=>{"stored"=>true, "indexed"=>true, "type"=>"int"}, "category"=>{"stored"=>true, "indexed"=>true, "type"=>"textgen"}, "includes"=>{"termOffsets"=>true, "stored"=>true, "indexed"=>true, "termVectors"=>true, "type"=>"text", "termPositions"=>true}, "title"=>{"stored"=>true, "multiValued"=>true, "indexed"=>true, "type"=>"text"}, "comments"=>{"stored"=>true, "indexed"=>true, "type"=>"text"}, "author"=>{"stored"=>true, "indexed"=>true, "type"=>"textgen"}, "content_type"=>{"stored"=>true, "multiValued"=>true, "indexed"=>true, "type"=>"string"}, "weight"=>{"stored"=>true, "indexed"=>true, "type"=>"float"}, "text"=>{"stored"=>false, "multiValued"=>true, "indexed"=>true, "type"=>"text"}, "id"=>{"required"=>true, "stored"=>true, "indexed"=>true, "type"=>"string"}, "subject"=>{"stored"=>true, "indexed"=>true, "type"=>"text"}, "text_rev"=>{"stored"=>false, "multiValued"=>true, "indexed"=>true, "type"=>"text_rev"}, "sku"=>{"stored"=>true, "indexed"=>true, "type"=>"textTight", "omitNorms"=>true}, "features"=>{"stored"=>true, "multiValued"=>true, "indexed"=>true, "type"=>"text"}, "links"=>{"stored"=>true, "multiValued"=>true, "indexed"=>true, "type"=>"string"}, "manu_exact"=>{"stored"=>false, "indexed"=>true, "type"=>"string"}, "inStock"=>{"stored"=>true, "indexed"=>true, "type"=>"boolean"}, "description"=>{"stored"=>true, "indexed"=>true, "type"=>"text"}, "alphaNameSort"=>{"stored"=>false, "indexed"=>true, "type"=>"alphaOnlySort"}, "manu"=>{"stored"=>true, "indexed"=>true, "type"=>"textgen", "omitNorms"=>true}, "last_modified"=>{"stored"=>true, "indexed"=>true, "type"=>"date"}, "payloads"=>{"stored"=>true, "indexed"=>true, "type"=>"payloads"}, "keywords"=>{"stored"=>true, "indexed"=>true, "type"=>"textgen"}}, "uniqueKey"=>"id", "version"=>"1.2", "types"=>{"pint"=>{:type=>:int, :index=>:untokenized_omit_norms}, "boolean"=>{:type=>:bool, :index=>:untokenized_omit_norms}, "tfloat"=>{:type=>nil, :index=>:untokenized_omit_norms}, "tdate"=>{:type=>nil, :index=>:untokenized_omit_norms}, "sfloat"=>{:type=>nil, :index=>:untokenized_omit_norms}, "phonetic"=>{:type=>:text}, "plong"=>{:type=>nil, :index=>:untokenized_omit_norms}, "pfloat"=>{:type=>:float, :index=>:untokenized_omit_norms}, "pdouble"=>{:type=>nil, :index=>:untokenized_omit_norms}, "binary"=>{:type=>nil, :index=>:untokenized}, "int"=>{:type=>nil, :index=>:untokenized_omit_norms}, "text"=>{:type=>:text}, "lowercase"=>{:type=>:text}, "date"=>{:type=>nil, :index=>:untokenized_omit_norms}, "sint"=>{:type=>nil, :index=>:untokenized_omit_norms}, "slong"=>{:type=>nil, :index=>:untokenized_omit_norms}, "text_rev"=>{:type=>:text}, "tint"=>{:type=>nil, :index=>:untokenized_omit_norms}, "tlong"=>{:type=>nil, :index=>:untokenized_omit_norms}, "tdouble"=>{:type=>nil, :index=>:untokenized_omit_norms}, "random"=>{:type=>nil, :index=>:untokenized}, "text_ws"=>{:type=>:text}, "textgen"=>{:type=>:text}, "string"=>{:type=>:string, :index=>:untokenized_omit_norms}, "double"=>{:type=>nil, :index=>:untokenized_omit_norms}, "pdate"=>{:type=>:date, :index=>:untokenized_omit_norms}, "sdouble"=>{:type=>nil, :index=>:untokenized_omit_norms}, "alphaOnlySort"=>{:type=>:text, :index=>:omit_norms}, "payloads"=>{:type=>:text}, "ignored"=>{:type=>:string, :index=>:untokenized}, "float"=>{:type=>nil, :index=>:untokenized_omit_norms}, "long"=>{:type=>nil, :index=>:untokenized_omit_norms}, "textTight"=>{:type=>:text}}, "dynamic_fields"=>{"*_tf"=>{"stored"=>true, "indexed"=>true, "type"=>"tfloat"}, "*_l"=>{"stored"=>true, "indexed"=>true, "type"=>"long"}, "*_b"=>{"stored"=>true, "indexed"=>true, "type"=>"boolean"}, "*_ti"=>{"stored"=>true, "indexed"=>true, "type"=>"tint"}, "random_*"=>{"type"=>"random"}, "*_d"=>{"stored"=>true, "indexed"=>true, "type"=>"double"}, "*_f"=>{"stored"=>true, "indexed"=>true, "type"=>"float"}, "*_tl"=>{"stored"=>true, "indexed"=>true, "type"=>"tlong"}, "*_tdt"=>{"stored"=>true, "indexed"=>true, "type"=>"tdate"}, "*_pi"=>{"stored"=>true, "indexed"=>true, "type"=>"pint"}, "*_s"=>{"stored"=>true, "indexed"=>true, "type"=>"string"}, "attr_*"=>{"stored"=>true, "multiValued"=>true, "indexed"=>true, "type"=>"textgen"}, "*_i"=>{"stored"=>true, "indexed"=>true, "type"=>"int"}, "*_t"=>{"stored"=>true, "indexed"=>true, "type"=>"text"}, "*_dt"=>{"stored"=>true, "indexed"=>true, "type"=>"date"}, "*_td"=>{"stored"=>true, "indexed"=>true, "type"=>"tdouble"}, "ignored_*"=>{"multiValued"=>true, "type"=>"ignored"}}, "defaultSearchField"=>"text"}}
+            puts "Writing default schema.yml"
+            s_yml = open("#{cwd}/#{project}/conf/schema.yml", "w")
+            s_yml << schema.to_yaml
+            s_yml.close  
+            puts "Writing default rackup file at #{cwd}/#{project}/config.ru"
+            rackup = open("#{cwd}/#{project}/config.ru", "w")      
+            rackup_body =<<END
+require 'rubygems'
+require 'sinatra'
+
+root_dir = File.dirname(__FILE__)
+
+set :environment, :production
+set :configuration, root_dir+"/conf/cheapskate.yml"
+set :site, :#{project}
+set :root,  root_dir
+
+set :logging, false
+disable :run
+
+FileUtils.mkdir_p 'log' unless File.exists?('log')
+log = File.new("log/\#{Sinatra::Application.site}.log", "a")
+STDOUT.reopen(log)
+STDERR.reopen(log)
+require 'cheap_skate'
+run CheapSkate::Application
+
+END
+            rackup << rackup_body
+            rackup.close
+          end
+        end
+      end
+
+    end
+        
+    def define_convertschema_task
+      desc "Parses a Solr schema.xml document and outputs a CheapSkate schema.yml.  Needs the arguments xml=/path/to/schema.xml Defaults to ./conf/schema.yml, use the yaml= argument to specify the output."
+      task "convertschema" do
+        raise ArgumentError, "No schema.xml specified.  Usage: cheapskate convertschema xml=/path/to/schema.xml" unless ENV['xml']
+        xml = open(ENV['xml'],'r')
+        yml = CheapSkate::Schema.xml_to_yaml(xml)
+        if ENV['yaml']
+          puts "Writing #{ENV['xml']} out to #{ENV['yaml']}."
+          outfile = open(ENV['yaml'],'w')
+        else
+          puts "Writing #{ENV['xml']} out to ./conf/schema.yml."          
+          outfile = open('./conf/schema.yml','w')
+        end
+        outfile << yml.to_s
+        outfile.close
+      end
+    end    
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Ross Singer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-28 00:00:00 -04:00
+date: 2010-06-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -91,8 +91,9 @@ dependencies:
   version_requirements: *id006
 description: A Solr-like interface for situations where running a Java application server is not an option (such as shared web hosting).
 email: rossfsinger@gmail.com
-executables: []
-
+executables: 
+- cheapskate
+- cheapskate
 extensions: []
 
 extra_rdoc_files: 
@@ -104,9 +105,11 @@ files:
 - config.ru-dist
 - lib/cheap_skate.rb
 - lib/cheap_skate/application.rb
+- lib/cheap_skate/cli.rb
 - lib/cheap_skate/index.rb
 - lib/cheap_skate/models.rb
 - lib/cheap_skate/schema.rb
+- lib/cheap_skate/tasks.rb
 - LICENSE
 - README
 has_rdoc: true