flex 0.1.0

data/lib/flex/api_methods.yml

@@ -0,0 +1,108 @@
+# These methods are available as Flex.<method> variable_hash
+# you can get the updated full reference and usage example of these methods
+# by just doing in the console:
+# >> puts Flex.info
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-indices-exists.html
+indices_exists: &exist
+  - HEAD
+  - /<<index>>
+
+# aliased
+exist?: *exist
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-create-index.html
+create_index: &create
+  - PUT
+  - /<<index>>
+  - settings:
+      number_of_shards: <<number_of_shards= 5 >>
+      number_of_replicas: <<number_of_replicas= 1 >>
+
+# aliased
+put_index: *create
+
+post_index:
+  - POST
+  - /<<index>>
+  - settings:
+      number_of_shards: <<number_of_shards= 5 >>
+      number_of_replicas: <<number_of_replicas= 1 >>
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-get-settings.html
+get_settings:
+  - GET
+  - /<<index>>/_settings
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-put-mapping.html
+put_mapping:
+  - PUT
+  - /<<index>>/<<type>>/_mapping
+  - <<type>>:
+      properties: <<properties>>
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-get-mapping.html
+get_mapping:
+  - GET
+  - /<<index>>/<<type>>/_mapping
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-delete-mapping.html
+delete_mapping:
+  - DELETE
+  - /<<index>>/<<type>>
+
+# http://www.elasticsearch.org/guide/reference/api/delete.html
+delete_index:
+  - DELETE
+  - /<<index>>
+
+# http://www.elasticsearch.org/guide/reference/api/delete-by-query.html
+delete_by_query:
+  - DELETE
+  - /<<index>>/<<type>>/_query
+  # pass :data variable query if you need
+
+# http://www.elasticsearch.org/guide/reference/api/bulk.html
+bulk:
+  - POST
+  - /_bulk
+  - << lines >>
+
+# http://www.elasticsearch.org/guide/reference/api/count.html
+count:
+  - GET
+  - /<<index>>/<<type>>/_count
+  # pass :data structure if you need
+
+# http://www.elasticsearch.org/guide/reference/api/admin-indices-stats.html
+stats:
+  - GET
+  - /<<index>>/_stats/<<end_point= ~ >>
+
+# You must pass the :data variable
+store: &store
+  - PUT
+  - /<<index>>/<<type>>/<<id>>
+
+# alias for symmetry with post_store
+put_store: *store
+
+# id is set by ES; you must pass :data
+post_store:
+  - POST
+  - /<<index>>/<<type>>
+
+remove:
+  - DELETE
+  - /<<index>>/<<type>>/<<id>>
+
+# http://www.elasticsearch.org/guide/reference/api/get.html
+get:
+  - GET
+  - /<<index>>/<<type>>/<<id>>
+
+# http://www.elasticsearch.org/guide/reference/api/multi-get.html
+multi_get:
+  - GET
+  - /<<index>>/<<type>>/_mget
+  - ids: << ids >>

data/lib/flex/class_proxy.rb

@@ -0,0 +1,12 @@
+module Flex
+  class ClassProxy
+    attr_reader :host_class
+    attr_accessor :variables
+
+    def initialize(host_class)
+      @host_class = host_class
+      @variables  = Variables.new
+    end
+
+  end
+end

data/lib/flex/configuration.rb

@@ -0,0 +1,57 @@
+module Flex
+  class Struct < OpenStruct
+
+    def configure
+      yield self
+    end
+
+  end
+
+  extend self
+
+  def load_http_client
+    if Gem::Specification.respond_to?(:find_all_by_name)
+      case
+        # terrible way to check whether a gem is available.
+        # Gem.available? was just perfect: that's probably the reason it has been deprecated!
+        # https://github.com/rubygems/rubygems/issues/176
+      when Gem::Specification::find_all_by_name('patron').any?
+        require 'patron'
+        Flex::HttpClients::Patron
+      when Gem::Specification::find_all_by_name('rest-client').any?
+        require 'rest-client'
+        Flex::HttpClients::RestClient
+      end
+    else
+      case
+      when Gem.available?('patron')
+        require 'patron'
+        Flex::HttpClients::Patron
+      when Gem.available?('rest-client')
+        require 'rest-client'
+        Flex::HttpClients::RestClient
+      end
+    end
+  end
+  private :load_http_client
+
+  Configuration = Struct.new :base_uri            => 'http://localhost:9200',
+                             :result_extenders    => [ Flex::Result::Document,
+                                                       Flex::Result::SourceDocument,
+                                                       Flex::Result::Search,
+                                                       Flex::Result::SourceSearch,
+                                                       Flex::Result::Bulk ],
+                             :logger              => Logger.new(STDERR),
+                             :variables           => Variables.new( :index      => nil,
+                                                                    :type       => nil,
+                                                                    :no_pruning => %w[match_all] ),
+                             :flex_models         => [],
+                             :config_file         => './config/flex.yml',
+                             :flex_dir            => './flex',
+                             :http_client         => load_http_client,
+                             :http_client_options => {},
+                             :debug               => true,
+                             :debug_result        => true,
+                             :debug_to_curl       => false,
+                             :raise_proc          => proc{|response| response.status >= 400}
+end

data/lib/flex/errors.rb

@@ -0,0 +1,42 @@
+module Flex
+
+  class ArgumentError          < ArgumentError; end
+  class SourceError            < StandardError; end
+  class MissingPartialError    < StandardError; end
+  class DocumentMappingError   < StandardError; end
+  class MissingIndexEntryError < StandardError; end
+  class ExistingIndexError     < StandardError; end
+  class MissingHttpClientError < StandardError; end
+  class MissingParentError     < StandardError; end
+
+  class HttpError < StandardError
+
+    attr_reader :response
+
+    def initialize(response, caller_line=nil)
+      @response    = response
+      @caller_line = caller_line
+    end
+
+    def status
+      response.status
+    end
+
+    def body
+      response.body
+    end
+
+    def to_s
+      log = "#{@caller_line}\n" if @caller_line
+      "#{log}#{status}: #{body}"
+    end
+
+    def to_hash
+      MultiJson.decode response.body
+    rescue MultiJson::DecodeError
+      {}
+    end
+
+  end
+
+end

data/lib/flex/http_clients/patron.rb

@@ -0,0 +1,27 @@
+module Flex
+  module HttpClients
+    module Patron
+      extend self
+
+      def request(method, path, data=nil, options={})
+        options = Utils.deep_merge_hashes(Configuration.http_client_options, options)
+        options = options.merge(:data => data) if data
+        session.request method.to_s.downcase.to_sym, path, {}, options
+      rescue ::Patron::TimeoutError
+        session.request method.to_s.downcase.to_sym, path, {}, options
+      end
+
+    private
+
+      def session
+        Thread.current[:flex_patron_session] ||= begin
+                                                   sess                       = ::Patron::Session.new
+                                                   sess.headers['User-Agent'] = "flex-#{Flex::VERSION}"
+                                                   sess.base_url              = Configuration.base_uri
+                                                   sess
+                                                 end
+      end
+
+    end
+  end
+end

data/lib/flex/http_clients/rest_client.rb

@@ -0,0 +1,38 @@
+module Flex
+  module HttpClients
+    module RestClient
+      extend self
+
+      def request(method, path, data=nil, options={})
+        options = Configuration.http_client_options.merge options
+        url     = Configuration.base_uri + path
+        args    = options.merge( :method  => method.to_s.downcase.to_sym,
+                                 :url     => url,
+                                 :payload => data )
+        response = ::RestClient::Request.new( args ).execute
+        extend_response(response, url)
+
+      rescue ::RestClient::ExceptionWithResponse, ::RestClient::RequestFailed => e
+        extend_response(e.response, url)
+      end
+
+    private
+
+      def extend_response(response, url)
+        response.extend ResponseExtension
+        response.url = url
+        response
+      end
+
+      module ResponseExtension
+        attr_accessor :url
+
+        def status
+          code.to_i
+        end
+
+      end
+
+    end
+  end
+end

data/lib/flex/loader.rb

@@ -0,0 +1,116 @@
+module Flex
+  module Loader
+
+    extend self
+    attr_accessor :host_classes
+    @host_classes = []
+
+    def self.included(base)
+      base.class_eval do
+        Flex::Loader.host_classes |= [base]
+        class << self; attr_reader :flex end
+        @flex = Flex::Loader::ClassProxy.new(base)
+      end
+    end
+
+    class ClassProxy < Flex::ClassProxy
+      attr_reader :templates, :partials
+
+      include Template::Info
+
+      def initialize(base)
+        super
+        @sources   = []
+        @templates = {}
+        @partials  = {}
+      end
+
+      # accepts a path to a file or YAML string
+      def load_source_for(klass, source, source_vars)
+        if source.nil? || source != /\n/
+          paths = [ "#{Configuration.flex_dir}/#{source}.yml",
+                    "#{Configuration.flex_dir}/#{Model::Manager.class_name_to_type(host_class.name)}.yml",
+                    source ]
+          source = paths.find {|p| File.exist?(p)}
+        end
+        raise ArgumentError, "expected a string (got #{source.inspect})." \
+              unless source.is_a?(String)
+        @sources << [klass, source, source_vars]
+        do_load_source(klass, source, source_vars)
+      end
+
+      # loads a Generic Template source
+      def load_source(source=nil, source_vars=nil)
+        load_source_for(Template, source, source_vars)
+      end
+
+      # loads a Search Template source
+      def load_search_source(source=nil, source_vars=nil)
+        load_source_for(Template::Search, source, source_vars)
+      end
+
+      # loads a SlimSearch Template source
+      def load_slim_search_source(source=nil, source_vars=nil)
+        load_source_for(Template::SlimSearch, source, source_vars)
+      end
+
+      # reloads the sources (useful in the console and used internally)
+      def reload!
+        @sources.each {|k,s,v| do_load_source(k,s,v)}
+      end
+
+      # adds a template instance and defines the template method in the host class
+      def add_template(name, template)
+        templates[name] = template
+        # no define_singleton_method in 1.8.7
+        host_class.instance_eval <<-ruby, __FILE__, __LINE__ + 1
+          def #{name}(vars={})
+            raise ArgumentError, "#{host_class}.#{name} expects a Hash (got \#{vars.inspect})" unless vars.is_a?(Hash)
+            #{host_class.respond_to?(:preprocess_variables) && 'preprocess_variables(vars)'}
+            flex.templates[:#{name}].render(vars)
+          end
+        ruby
+      end
+
+      # http://www.elasticsearch.org/guide/reference/api/multi-search.html
+      # request may be a hash with the templates names as keys and the variable hash as value
+      # or you can also use an array of arrays.
+      # The variables are an hash of variables that will be used to render the msearch template
+      def multi_search(requests, variables={})
+        lines    = requests.map { |name, vars| templates[name].to_msearch(vars) }.join()
+        template = Template.new('GET', '/<<index>>/<<type>>/_msearch')
+        template.send(:do_render, variables.merge(:data => lines)) do |http_response|
+          responses   = []
+          es_response = MultiJson.decode(http_response.body)
+          es_response['responses'].each_with_index do |result, i|
+            responses << Result.new(templates[requests[i].first], requests[i].last, http_response, result)
+          end
+          es_response['responses'] = responses
+          def es_response.responses
+            self['responses']
+          end
+          es_response
+        end
+      end
+
+    private
+
+      def do_load_source(klass, source, source_vars)
+        source = Utils.erb_process(source) unless source.match("\n") # skips non-path
+        hash   = Utils.data_from_source(source)
+        hash.delete('ANCHORS')
+        hash.each do |name, structure|
+          if name.to_s =~ /^_/ # partial
+            partial = Template::Partial.new(structure, self)
+            partials[name.to_sym] = partial
+          else
+            template = klass.new(*structure).setup(self, name, source_vars)
+            add_template(name.to_sym, template)
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/flex/logger.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+module Flex
+  class Logger < ::Logger
+
+    def initialize(*)
+      super
+      self.level     = ::Logger::INFO
+      self.progname  = "FLEX"
+      self.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+    end
+
+  end
+end

data/lib/flex/model.rb

@@ -0,0 +1,24 @@
+module Flex
+  module Model
+
+    def self.included(base)
+      base.class_eval do
+        class << self; attr_reader :flex end
+        @flex ||= Flex::Model::ClassProxy.new(base)
+      end
+    end
+
+    def flex
+      @flex ||= InstanceProxy.new(self)
+    end
+
+    def flex_source
+      to_hash.reject {|k| k.to_s =~ /^_*id$/}.to_json
+    end
+
+    def flex_indexable?
+      true
+    end
+
+  end
+end