bento_search 0.0.1

data/app/views/bento_search/_link.html.erb

@@ -0,0 +1,4 @@
+<%= link_to(link.label, link.url, 
+      :rel => link.rel, 
+      :class => (link.style_classes + ["bento_search_link", "btn", "btn-mini"])
+      ) -%>

data/app/views/bento_search/_search_error.html.erb

@@ -0,0 +1,22 @@
+<div class="bento_search_error alert alert-error">
+  <p>
+    <%= t("bento_search.search_error") %>
+  </p>
+  
+  <div style="overflow-x:scroll">
+    <p>
+      <%= results.error %>
+    </p>
+    <p>
+    
+      <% if Rails.application.config.consider_all_requests_local && results.error["exception"] %>
+        <ul>
+        <% results.error["exception"].backtrace.each do |line| %>
+          <li><%= line %></li>
+        <% end %>  
+        <ul>
+      <% end %>
+    </p>
+  </div>
+  
+</div>

data/app/views/bento_search/_std_item.html.erb

@@ -0,0 +1,39 @@
+<% #  must pass in local 'item' OR 'std_item' (as used by rails collection
+   #   rendering) that's a BentoSearch::ResultItem 
+     
+  item = local_assigns[:item] || local_assigns[:std_item]
+
+%>
+
+<div class="bento_item">
+  <%= bento_item_title(item) %>
+    
+  <div class="bento_item_body">
+    
+    
+    <% if item.authors.length > 0 %>
+      <p class="bento_item_authors">  
+        <%= bento_item_authors(item) %>            
+      </p>
+    <% end %>      
+          
+    <% if item.published_in %>
+      <p class="bento_item_row published_in">
+        <span class="bento_value"><%= item.published_in %> </span>
+      </p>
+    <% end %>
+    
+    <% if item.abstract %>
+      <p class="bento_item_abstract">
+        <%= bento_abstract_truncate( item.abstract ) %>
+      </p>
+    <% end %>
+    
+    <% if item.other_links.present? %>
+      <p class="bento_item_other_links">
+        <%= render :partial => "bento_search/link", :collection => item.other_links %>
+      </p>
+    <% end %>
+  </div>
+  
+</div>

data/app/views/bento_search/search/search.html.erb

@@ -0,0 +1 @@
+<%= bento_search(@results) %>

data/config/locales/en.yml

@@ -0,0 +1,25 @@
+en:
+  bento_search:
+    ajax_loading: "Loading..."
+    no_results: "No results found."
+    search_error: "Sorry! An error occured and results could not be retrieved."
+    missing_title: "[Title Missing]"
+    format:
+      # Schema.org formats
+      Article: Article
+      Book: Book
+      Movie: Movie
+      MusicRecording: Musical Recording
+      Photograph: Photo
+      SoftwareApplication: Software
+      # And some custom ones that Schema.org didn't cover, alas
+      serial: Magazine or Journal
+      dissertation: Dissertation or Thesis
+    sort_keys:
+      title_asc: "title" 
+      date_desc: "publication date" 
+      relevance: "relevance"
+      author_asc: "author"
+      num_cite_desc: "citation count"
+    eds:
+      record_not_available: "Record Not Available -- log in to see full results"

data/lib/bento_search.rb

@@ -0,0 +1,29 @@
+require "bento_search/engine"
+require 'bento_search/routes'
+require 'confstruct'
+
+# ugh, sorry:
+require File.dirname(__FILE__) + '/../app/models/bento_search/registrar'
+
+module BentoSearch  
+  
+  def self.global_registrar
+    @@global_registrar ||= BentoSearch::Registrar.new
+  end
+       
+  def self.register_engine(id, &block)
+    global_registrar.register_engine(id, &block)    
+  end
+  
+  def self.get_engine(id)
+    global_registrar.get_engine(id)
+  end
+      
+  # Mostly just used for testing
+  def self.reset_engine_registrations!
+    global_registrar.reset_engine_registrations!
+  end
+
+end
+
+

data/lib/bento_search/engine.rb

@@ -0,0 +1,5 @@
+module BentoSearch
+  class Engine < ::Rails::Engine
+    #isolate_namespace BentoSearch
+  end
+end

data/lib/bento_search/routes.rb

@@ -0,0 +1,45 @@
+# -*- encoding : utf-8 -*-
+module BentoSearch
+  class Routes
+
+    def initialize(router, options = {})
+      @router = router
+      @options = {:scope => "/bento"}.merge(options)
+    end
+
+    def draw
+      route_sets.each do |r|
+        self.send(r)
+      end
+    end
+
+    protected
+
+    def add_routes &blk
+      @router.instance_exec(@options, &blk)
+    end
+
+    def route_sets
+      (@options[:only] || default_route_sets) - (@options[:except] || [])
+    end
+
+    def default_route_sets
+      # :search should always be LAST
+      [:search]
+    end
+
+    module RouteSets
+      
+      def search
+        add_routes do |options|
+          scope options[:scope] do
+            get ":engine_id" => "bento_search/search#search", :as => "to_bento_search"
+          end
+        end
+        
+      end
+        
+    end
+    include RouteSets
+  end
+end

data/lib/bento_search/version.rb

@@ -0,0 +1,3 @@
+module BentoSearch
+  VERSION = "0.0.1"
+end

data/lib/generators/bento_search/pull_ebsco_dbs_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+module BentoSearch
+  class PullEbscoDbsGenerator < ::Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    
+    desc "Pull avail dbs from EBSCO info task, write to source file that defines an array in ruby global variable."
+    
+    argument :engine_id, :type => :string
+
+    class_option :output_file, :type => :string, :default => "./config/ebsco_dbs.rb", :description => "filepath to write ruby file"
+    class_option :global_name, :type => :string, :default => "$ebsco_dbs", :description => "global variable to set in generated source file" 
+    
+    def generate
+      engine  = BentoSearch.get_engine( engine_id )
+      
+      @dbs    = engine.get_info.xpath("./info/dbInfo/db") #.sort_by {|n| n["shortName"]}
+      
+      
+      template("ebsco_global_var.erb", options.output_file)
+      
+    end
+    
+  end
+end

data/lib/generators/bento_search/templates/ebsco_global_var.erb

@@ -0,0 +1,6 @@
+<%= options.global_name %> = []
+
+  <%-  @dbs.each do |db| -%>
+    <%= options.global_name %>.push( '<%= db["shortName"] %>' )  # <%= db["longName"] -%> 
+  <%- end -%>
+

data/lib/http_client_patch/include_client.rb

@@ -0,0 +1,86 @@
+# Submitted to HTTPClient, if it doesn't make it there i may make it it's own
+# gem, in the meantime it's here as HTTPClientPatch::IncludeClient
+
+# It is useful to re-use a HTTPClient instance for multiple requests, to
+# re-use HTTP 1.1 persistent connections. 
+#
+# To do that, you sometimes want to store an HTTPClient instance in a global/
+# class variable location, so it can be accessed and re-used. 
+#
+# This mix-in makes it easy to create class-level access to one or more
+# HTTPClient instances. The HTTPClient instances are lazily initialized
+# on first use (to, for instance, avoid interfering with WebMock/VCR),
+# and are initialized in a thread-safe manner. Note that a 
+# HTTPClient, once initialized, is safe for use in multiple threads.
+#
+# Note that you `extend` HTTPClient::IncludeClient, not `include. 
+#
+#    require 'httpclient/include_client'
+#    class Widget
+#       extend HTTPClient::IncludeClient
+#
+#       include_http_client
+#       # and/or, specify more stuff
+#       include_http_client('http://myproxy:8080', :method_name => :my_client) do |client|
+#          # any init you want
+#          client.set_cookie_store nil
+#          client.
+#       end
+#    end
+#
+# That creates two HTTPClient instances available at the class level.
+# The first will be available from Widget.http_client (default method
+# name for `include_http_client`), with default initialization. 
+#
+# The second will be available at Widget.my_client, with the init arguments
+# provided, further initialized by the block provided. 
+#
+# In addition to a class-level method, for convenience instance-level methods
+# are also provided. Widget.http_client is identical to Widget.new.http_client
+#
+#
+class HTTPClientPatch
+  module IncludeClient
+        
+
+    def include_http_client(*args, &block)
+      # We're going to dynamically define a class
+      # to hold our state, namespaced, as well as possibly dynamic
+      # name of cover method. 
+      method_name = (args.last.delete(:method_name) if args.last.kind_of? Hash) || :http_client
+      args.pop if args.last == {} # if last arg was named methods now empty, remove it.       
+      
+      # By the amazingness of closures, we can create these things
+      # in local vars here and use em in our method, we don't even
+      # need iVars for state. 
+      client_instance = nil
+      client_mutex = Mutex.new
+      client_args = args
+      client_block = block
+
+      # to define a _class method_ on the specific class that's currently
+      # `self`, we have to use this bit of metaprogramming, sorry. 
+      (class << self; self ; end).instance_eval do      
+        define_method(method_name) do                            
+          # implementation copied from ruby stdlib singleton
+          # to create this global obj thread-safely.
+          return client_instance if client_instance
+          client_mutex.synchronize do
+            return client_instance if client_instance
+            # init HTTPClient with specified args/block  
+            client_instance = HTTPClient.new(*client_args)
+            client_block.call(client_instance) if client_block
+          end
+          return client_instance
+        end
+      end
+      
+      # And for convenience, an  _instance method_ on the class that just
+      # delegates to the class method. 
+      define_method(method_name) do
+        self.class.send(method_name)
+      end
+          
+    end
+  end
+end

data/lib/tasks/bento_search_tasks.rake

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

data/test/dummy/README.rdoc

@@ -0,0 +1,261 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+2. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+3. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+4. Follow the guidelines to start developing your application. You can find
+the following resources handy:
+
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Debugging Rails
+
+Sometimes your application goes wrong. Fortunately there are a lot of tools that
+will help you debug it and get it back on the rails.
+
+First area to check is the application log files. Have "tail -f" commands
+running on the server.log and development.log. Rails will automatically display
+debugging and runtime information to these files. Debugging info will also be
+shown in the browser on requests from 127.0.0.1.
+
+You can also log your own messages directly into the log file from your code
+using the Ruby logger class from inside your controllers. Example:
+
+  class WeblogController < ActionController::Base
+    def destroy
+      @weblog = Weblog.find(params[:id])
+      @weblog.destroy
+      logger.info("#{Time.now} Destroyed Weblog ID ##{@weblog.id}!")
+    end
+  end
+
+The result will be a message in your log file along the lines of:
+
+  Mon Oct 08 14:22:29 +1000 2007 Destroyed Weblog ID #1!
+
+More information on how to use the logger is at http://www.ruby-doc.org/core/
+
+Also, Ruby documentation can be found at http://www.ruby-lang.org/. There are
+several books available online as well:
+
+* Programming Ruby: http://www.ruby-doc.org/docs/ProgrammingRuby/ (Pickaxe)
+* Learn to Program: http://pine.fm/LearnToProgram/ (a beginners guide)
+
+These two books will bring you up to speed on the Ruby language and also on
+programming in general.
+
+
+== Debugger
+
+Debugger support is available through the debugger command when you start your
+Mongrel or WEBrick server with --debugger. This means that you can break out of
+execution at any point in the code, investigate and change the model, and then,
+resume execution! You need to install ruby-debug to run the server in debugging
+mode. With gems, use <tt>sudo gem install ruby-debug</tt>. Example:
+
+  class WeblogController < ActionController::Base
+    def index
+      @posts = Post.all
+      debugger
+    end
+  end
+
+So the controller will accept the action, run the first line, then present you
+with a IRB prompt in the server window. Here you can do things like:
+
+  >> @posts.inspect
+  => "[#<Post:0x14a6be8
+          @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>,
+       #<Post:0x14a6620
+          @attributes={"title"=>"Rails", "body"=>"Only ten..", "id"=>"2"}>]"
+  >> @posts.first.title = "hello from a debugger"
+  => "hello from a debugger"
+
+...and even better, you can examine how your runtime objects actually work:
+
+  >> f = @posts.first
+  => #<Post:0x13630c4 @attributes={"title"=>nil, "body"=>nil, "id"=>"1"}>
+  >> f.
+  Display all 152 possibilities? (y or n)
+
+Finally, when you're ready to resume execution, you can enter "cont".
+
+
+== Console
+
+The console is a Ruby shell, which allows you to interact with your
+application's domain model. Here you'll have all parts of the application
+configured, just like it is when the application is running. You can inspect
+domain models, change values, and save to the database. Starting the script
+without arguments will launch it in the development environment.
+
+To start the console, run <tt>rails console</tt> from the application
+directory.
+
+Options:
+
+* Passing the <tt>-s, --sandbox</tt> argument will rollback any modifications
+  made to the database.
+* Passing an environment name as an argument will load the corresponding
+  environment. Example: <tt>rails console production</tt>.
+
+To reload your controllers and models after launching the console run
+<tt>reload!</tt>
+
+More information about irb can be found at:
+link:http://www.rubycentral.org/pickaxe/irb.html
+
+
+== dbconsole
+
+You can go to the command line of your database directly through <tt>rails
+dbconsole</tt>. You would be connected to the database with the credentials
+defined in database.yml. Starting the script without arguments will connect you
+to the development database. Passing an argument will connect you to a different
+database, like <tt>rails dbconsole production</tt>. Currently works for MySQL,
+PostgreSQL and SQLite 3.
+
+== Description of Contents
+
+The default directory structure of a generated Ruby on Rails application:
+
+  |-- app
+  |   |-- assets
+  |       |-- images
+  |       |-- javascripts
+  |       `-- stylesheets
+  |   |-- controllers
+  |   |-- helpers
+  |   |-- mailers
+  |   |-- models
+  |   `-- views
+  |       `-- layouts
+  |-- config
+  |   |-- environments
+  |   |-- initializers
+  |   `-- locales
+  |-- db
+  |-- doc
+  |-- lib
+  |   `-- tasks
+  |-- log
+  |-- public
+  |-- script
+  |-- test
+  |   |-- fixtures
+  |   |-- functional
+  |   |-- integration
+  |   |-- performance
+  |   `-- unit
+  |-- tmp
+  |   |-- cache
+  |   |-- pids
+  |   |-- sessions
+  |   `-- sockets
+  `-- vendor
+      |-- assets
+          `-- stylesheets
+      `-- plugins
+
+app
+  Holds all the code that's specific to this particular application.
+
+app/assets
+  Contains subdirectories for images, stylesheets, and JavaScript files.
+
+app/controllers
+  Holds controllers that should be named like weblogs_controller.rb for
+  automated URL mapping. All controllers should descend from
+  ApplicationController which itself descends from ActionController::Base.
+
+app/models
+  Holds models that should be named like post.rb. Models descend from
+  ActiveRecord::Base by default.
+
+app/views
+  Holds the template files for the view that should be named like
+  weblogs/index.html.erb for the WeblogsController#index action. All views use
+  eRuby syntax by default.
+
+app/views/layouts
+  Holds the template files for layouts to be used with views. This models the
+  common header/footer method of wrapping views. In your views, define a layout
+  using the <tt>layout :default</tt> and create a file named default.html.erb.
+  Inside default.html.erb, call <% yield %> to render the view using this
+  layout.
+
+app/helpers
+  Holds view helpers that should be named like weblogs_helper.rb. These are
+  generated for you automatically when using generators for controllers.
+  Helpers can be used to wrap functionality for your views into methods.
+
+config
+  Configuration files for the Rails environment, the routing map, the database,
+  and other dependencies.
+
+db
+  Contains the database schema in schema.rb. db/migrate contains all the
+  sequence of Migrations for your schema.
+
+doc
+  This directory is where your application documentation will be stored when
+  generated using <tt>rake doc:app</tt>
+
+lib
+  Application specific libraries. Basically, any kind of custom code that
+  doesn't belong under controllers, models, or helpers. This directory is in
+  the load path.
+
+public
+  The directory available for the web server. Also contains the dispatchers and the
+  default HTML files. This should be set as the DOCUMENT_ROOT of your web
+  server.
+
+script
+  Helper scripts for automation and generation.
+
+test
+  Unit and functional tests along with fixtures. When using the rails generate
+  command, template test files will be generated for you and placed in this
+  directory.
+
+vendor
+  External libraries that the application depends on. Also includes the plugins
+  subdirectory. If the app has frozen rails, those gems also go here, under
+  vendor/rails/. This directory is in the load path.