ruby-montage 0.5.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2251111d886899ecbf95641a1985d604ec569d6
-  data.tar.gz: f63b762b828e1200f86fc62cbddde07aada43181
+  metadata.gz: 7e3dfa2aad01ef822edd6bc91a7b316694912d0f
+  data.tar.gz: 08a3fc32a12b85d0144b8be7855c01cdd2a2d4b6
 SHA512:
-  metadata.gz: 2bcd8a615fda2c6052a44aa8cb6c4b4155570784c39932a78dfc77dea55e257f5a30346e52dd529f6eed2a1db2171e6a8e07d393d922d337cf484b6c0c734c1c
-  data.tar.gz: 2009c3a8c71ecdbd8ac699a2c4c618ee1b431d692d665c97968ac67ba20d7c924560fe3c5d81a3f28ce0902959b11effaa0a9a9bddb49a8e395cb440f011652c
+  metadata.gz: 4b7a79943fbca4d1ca5b7bcf1abc72e9383881a6def914937dc9c6aad289e396a45d3458c39ee6620dcf68829ee05fe37f13ff7b8d96d1c353c36e3665448454
+  data.tar.gz: a1cc37f0d95359cefaab29a32a6b51fcacb717df19e486df23c1780651a684d743330415d595a6a5f02d6526daeebe3d8441a575a39c7367e919161fd75e0759

data/.gitignore

@@ -12,3 +12,5 @@
 tmp.json
 ruby-montage-*.gem
 /build
+*.swp
+*.scratch

data/README.md

@@ -1,6 +1,7 @@
 [![Code Climate](https://codeclimate.com/github/EditLLC/ruby-montage/badges/gpa.svg)](https://codeclimate.com/github/EditLLC/ruby-montage)
 [![Circle CI](https://circleci.com/gh/EditLLC/ruby-montage/tree/master.svg?style=svg)](https://circleci.com/gh/EditLLC/ruby-montage/tree/master)
 [![codecov.io](http://codecov.io/github/EditLLC/ruby-montage/coverage.svg?branch=master)](http://codecov.io/github/EditLLC/ruby-montage?branch=master)
+[![Codetree](https://codetree.com/images/managed-with-codetree.svg)](https://codetree.com/projects/a8d5)
 
 # Ruby Montage
 
@@ -33,6 +34,7 @@ client = Montage::Client.new do |c|
   c.api_version # Optional, defaults to 1
   c.domain = "test" # Your Montage subdomain
   c.url_prefix = "https://testco.mtnge.com" # Optional, defaults to the montage dev server
+  c.environment = 'production' # Optional, defaults to production.  Valid options are 'production' and 'development'
 end
 
 response = client.auth

data/Rakefile

@@ -8,5 +8,9 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
+task :console do
+  exec 'pry -r montage -I ./lib'
+end
+
 desc "Run tests"
-task :default => :test
+task :default => :test

data/bin/console

@@ -9,6 +9,3 @@ require "montage"
 # (If you use this, don't forget to add pry to your Gemfile!)
 require "pry"
 Pry.start
-
-require "irb"
-IRB.start

data/lib/montage/client.rb

@@ -13,22 +13,61 @@ module Montage
     include Schemas
     include Documents
 
-    attr_accessor :token, :username, :password, :domain, :api_version, :url_prefix
-
+    attr_accessor :token,
+                  :username,
+                  :password,
+                  :domain,
+                  :api_version,
+                  :environment
+
+    # Initializes the client instance
+    #
+    # * *Attributes* :
+    #   - +token+ -> API access token required for requests, does not expire
+    #   - +username+ -> Montage username credential
+    #   - +password+ -> Montage password credential
+    #   - +domain+ -> Project subdomain, required for initialization
+    #   - +api_version+ -> API version to query against, defaults to 1
+    #   - +environment+ -> Specifies desired environment for requests, defaults
+    #     to 'production'. Valid options are 'development' and 'production'.
+    # * *Returns* :
+    #   - A valid Montage::Client instance
+    # * *Raises* :
+    #   - +MissingAttributeError+ -> If the domain attribute is not specified
+    #   - +InvalidEnvironment+ -> If the environment attribute is not set to 'production' or 'development'
+    #
     def initialize
       @api_version = 1
+      @environment ||= "production"
       yield(self) if block_given?
-      raise MissingAttributeError, "You must declare the domain attribute" unless @domain
+      fail MissingAttributeError, "You must declare the domain attribute" unless @domain
+      fail InvalidEnvironment, "Valid options are 'production' and 'development'" unless environment_valid?
     end
 
-    def default_url_prefix
-      "https://#{domain}.mntge.com"
+    # Verifies the Montage::Client instance environment
+    #
+    # * *Returns* :
+    #   - A boolean
+    #
+    def environment_valid?
+      %w(production development).include?(@environment)
     end
 
-    def content_type
-      "application/json"
+    # Generates a base url for requests using the supplied environment and domain
+    #
+    # * *Returns* :
+    #   - A string containing the constructed url
+    #
+    def default_url_prefix
+      return "https://#{domain}.dev.montagehot.club" if @environment == "development"
+      return "https://#{domain}.mntge.com" if @environment == "production"
     end
 
+    # Attempts to authenticate with the Montage API
+    #
+    # * *Returns* :
+    #   - A hash containing a valid token or an error string, oh no!
+    #
     def auth
       build_response("token") do
         connection.post do |req|
@@ -39,6 +78,18 @@ module Montage
       end
     end
 
+    # Requests resources from the Montage API, TODO:ADD EXAMPLES
+    #
+    # * *Args*    :
+    #   - +url+ -> The url of the targeted resource
+    #   - +resource_name+ -> The name of the targeted resource
+    #   - +options+ -> A hash of desired options
+    # * *Returns* :
+    #   * A Montage::Response Object containing:
+    #     - A http status code
+    #     - The response body
+    #     - The resource name
+    #
     def get(url, resource_name, options = {})
       build_response(resource_name) do
         connection.get do |req|
@@ -48,6 +99,18 @@ module Montage
       end
     end
 
+    # Posts to the Montage API with a JSON options string, TODO:ADD EXAMPLES
+    #
+    # * *Args*    :
+    #   - +url+ -> The url of the targeted resource
+    #   - +resource_name+ -> The name of the targeted resource
+    #   - +options+ -> A hash of desired options
+    # * *Returns* :
+    #   * A Montage::Response Object containing:
+    #     - A http status code
+    #     - The response body
+    #     - The resource name
+    #
     def post(url, resource_name, options = {})
       build_response(resource_name) do
         connection.post do |req|
@@ -57,6 +120,18 @@ module Montage
       end
     end
 
+    # Updates an existing Montage resource with a JSON options string, TODO:ADD EXAMPLES
+    #
+    # * *Args*    :
+    #   - +url+ -> The url of the targeted resource
+    #   - +resource_name+ -> The name of the targeted resource
+    #   - +options+ -> A hash of desired options
+    # * *Returns* :
+    #   * A Montage::Response Object containing:
+    #     - A http status code
+    #     - The response body
+    #     - The resource name
+    #
     def put(url, resource_name, options = {})
       build_response(resource_name) do
         connection.put do |req|
@@ -66,6 +141,18 @@ module Montage
       end
     end
 
+    # Removes an existing Montage resource with a JSON options string, TODO:ADD EXAMPLES
+    #
+    # * *Args*    :
+    #   - +url+ -> The url of the targeted resource
+    #   - +resource_name+ -> The name of the targeted resource
+    #   - +options+ -> A hash of desired options
+    # * *Returns* :
+    #   * A Montage::Response Object containing:
+    #     - A http status code
+    #     - The response body
+    #     - The resource name
+    #
     def delete(url, resource_name, options = {})
       build_response(resource_name) do
         connection.delete do |req|
@@ -75,37 +162,74 @@ module Montage
       end
     end
 
+    # Sets the authentication token on the client instance and http headers
+    #
+    # * *Returns* :
+    #   - A string with the proper token interpolated
+    #
     def set_token(token)
       @token = token
       connection.headers["Authorization"] = "Token #{token}"
     end
 
+    # Checks the response body for an errors key and a successful http status code
+    #
+    # * *Args*    :
+    #   - +response+ -> The Montage API response
+    # * *Returns* :
+    #   - A boolean
+    #
     def response_successful?(response)
       return false if response.body["errors"]
       response.success?
     end
 
-    def build_response(resource_name, &block)
+    # Instantiates a response object based on the yielded block
+    #
+    # * *Args*    :
+    #   - +resource_name+ -> The name of the Montage resource
+    # * *Returns* :
+    #   * A Montage::Response Object containing:
+    #     - A http status code
+    #     - The response body
+    #     - The resource name
+    #
+    def build_response(resource_name)
       response = yield
       resource = response_successful?(response) ? resource_name : "error"
 
       response_object = Montage::Response.new(response.status, response.body, resource)
 
-      if resource_name == "token" && response.success?
-        set_token(response_object.token.value)
-      end
+      set_token(response_object.token.value) if resource_name == "token" && response.success?
 
       response_object
     end
 
+    # Supplies the Faraday connection with proper headers
+    #
+    # * *Returns* :
+    #   - A hash of instance specific headers for requests
+    #
+    def connection_headers
+      {
+        "User-Agent" => "Montage Ruby v#{Montage::VERSION}",
+        "Content-Type" => "application/json",
+        "Accept" => "*/*",
+        "Authorization" => "Token #{token}",
+        "Referer" => "#{default_url_prefix}/"
+      }
+    end
+
+    # Creates an Faraday connection instance for requests
+    #
+    # * *Returns* :
+    #   - A Faraday connection object with an instance specific configuration
+    #
     def connection
       @connect ||= Faraday.new do |f|
         f.adapter :net_http
-        f.url_prefix = "#{url_prefix || default_url_prefix}/api/v#{api_version}/"
-        f.headers["User-Agent"] = "Montage Ruby v#{Montage::VERSION}"
-        f.headers["Content-Type"] = content_type
-        f.headers["Accept"] = "*/*"
-        f.headers["Authorization"] = "Token #{token}"
+        f.headers = connection_headers
+        f.url_prefix = "#{default_url_prefix}/api/v#{api_version}/"
         f.response :json, content_type: /\bjson$/
       end
     end

data/lib/montage/client/documents.rb

@@ -1,28 +1,50 @@
 module Montage
   class Client
     module Documents
-      # Public: Get a list of documents
-      #
-      # Params:
-      #   schema - *Required* The name of the schema to run the query against
-      #   query  - *Optional* A Montage::Query object to pass along with the request
-      #
-      # Returns a Montage::Response
-      #
-      def documents(schema, query = {})
-        post("schemas/#{schema}/query/", "document", query)
-      end
-
-      # Public: Fetch a document
-      #
-      # Params:
-      #   schema        - *Required* The name of the schema to fetch the document from
-      #   document_uuid - *Required* The uuid of the document to fetch
-      #
-      # Returns a Montage::Response
-      #
-      def document(schema, document_uuid)
-        get("schemas/#{schema}/#{document_uuid}/", "document")
+      # Public: Get a list of documents.  Batch and single queries are supported
+      # via the formatting listed below.
+      #
+      # * *Args* :
+      #   - +queries+ -> A Montage::Query object or batch of objects to pass
+      #     along with the request
+      # * *Returns* :
+      #   - A Montage::Response with a raw body that will resemble:
+      #    {
+      #      "data"=> {
+      #        "query1"=> [
+      #          {
+      #            "name"=>"happy accidents everywhere",
+      #            "price"=>"999,999,999",
+      #            "signed"=>true,
+      #            "id"=>"-1"
+      #          }
+      #        ]
+      #      }
+      #    }
+      # * *Examples* :
+      #   - A Single Query :
+      #
+      #    {
+      #      "query1" => {
+      #        "$schema" => "bob_ross_paintings",
+      #        "$query" => [
+      #          ["$filter", [
+      #            ["rating", ['$gt', 8]]
+      #          ]],
+      #          ["$limit", 1]
+      #        ]
+      #      }
+      #    }
+      #
+      #   - Batch Queries :
+      #
+      #    {
+      #      query1: { '$schema': 'bob_ross_paintings', ... },
+      #      query2: { '$schema': 'happy_little_trees', ... }
+      #    }
+      #
+      def documents(queries)
+        post("query/", "document", queries)
       end
 
       # Public: Get the set of documents for the given cursor

data/lib/montage/errors.rb

@@ -1,5 +1,7 @@
 module Montage
+  class ClauseFormatError < StandardError; end
+  class InvalidAttributeFormat < StandardError; end
+  class InvalidEnvironment < StandardError; end
   class MissingAttributeError < StandardError; end
-
   class QueryError < StandardError; end
 end

data/lib/montage/query.rb

@@ -1,5 +1,6 @@
 require 'montage/errors'
-require 'montage/query_parser'
+require 'montage/query/query_parser'
+require 'montage/query/order_parser'
 require 'montage/support'
 require 'json'
 
@@ -7,113 +8,187 @@ module Montage
   class Query
     include Montage::Support
 
-    attr_accessor :query
+    attr_accessor :options
+    attr_reader :schema
 
-    def initialize
-      @query = { filter: {} }
+    # Initializes the query instance via a params hash
+    #
+    # * *Attributes* :
+    #   - +schema+ -> The name of the schema you wish to query.  Alphanumeric
+    #     characters and underscores are allowed.
+    #   - +options+ -> A query hash containing desired options
+    # * *Returns* :
+    #   - A valid Montage::Query instance
+    # * *Raises* :
+    #   - +InvalidAttributeFormat+ -> If the declared schema is not a string or
+    #     contains non-alphanumeric characters.  Underscore ("_") is allowed!
+    # * *Examples* :
+    #    @query = Montage::Query.new(schema: 'testing')
+    #    => <Montage::Query:ID @query={"$schema"=>"testing", "$query"=>[["$filter", []]]}, @schema="testing">
+    #
+    def initialize(params = {})
+      @schema = params[:schema]
+      @options = {
+        "$schema" => @schema,
+        "$query" => [
+          ["$filter", []]
+        ]
+      }
+      fail(
+        InvalidAttributeFormat, "Schema attribute must be declared and valid!"
+      ) unless schema_valid?
     end
 
-    # Defines the limit to apply to the query, defaults to nil
-    #
-    # Merges a hash:
-    #  { limit: 10 }
+    # Validates the Montage::Query schema attribute
     #
-    # Returns self
+    # * *Returns* :
+    #   - A boolean
     #
-    def limit(max = nil)
-      clone.tap { |r| r.query.merge!(limit: max) }
+    def schema_valid?
+      @schema.is_a?(String) && @schema.index(/\W+/).nil?
     end
 
-    # Defines the offset to apply to the query, defaults to nil
+    # Adds a query parameter to Montage::Query instances in the form of
+    # an array. Checks for existing array elements and replaces them if found.
     #
-    # Merges a hash:
-    #   { offset: 10 }
+    # * *Args* :
+    #   - +query_param+ -> A query-modifing parameter in the form of an array.
+    #     Composed of a ReQON supported string as a designator and an
+    #     associated value.
     #
-    # Returns a copy of self
+    # * *Returns* :
+    #   - The updated array
     #
-    def offset(value = nil)
-      clone.tap { |r| r.query.merge!(offset: value) }
-    end
+    def merge_array(query_param)
+      arr = options["$query"]
+      position = arr.index(arr.assoc(query_param[0]))
 
-    # Defines the order clause for the query and merges it into the query hash
-    #
-    # Accepts either a string or a hash:
-    #   order("foo asc") or
-    #   order(:foo => :asc) or
-    #   order(:foo => "asc")
-    #
-    # Defaults the direction to asc if no value is passed in for that, or if it is not a valid value
-    #
-    # Merges a hash:
-    #   { order: "foo asc" }
-    #
-    # Returns a copy of self
-    #
-    def order(clause = {})
-      if clause.is_a?(Hash)
-        direction = clause.values.first.to_s
-        field = clause.keys.first.to_s
+      if position.nil?
+        arr.push(query_param)
       else
-        direction = clause.split(" ")[1]
-        field = clause.split(" ")[0]
-        direction = "asc" unless %w(asc desc).include?(direction)
+        arr[position] = query_param
       end
-
-      clone.tap{ |r| r.query.merge!(order_by: field, ordering: direction) }
     end
 
-    # Parses the SQL string passed into the method
-    #
-    # Raises an exception if it is not a valid query (at least three "words"):
-    #   parse_string_clause("foo bar")
-    #
-    # Raises an exception if the operator given is not a valid operator
-    #   parse_string_clause("foo * 'bar'")
+    # Defines the limit to apply to the query, defaults to nil
     #
-    # Returns a hash:
-    #   parse_string_clause("foo <= 1")
-    #   => { foo__lte: 1.0 }
+    # * *Args* :
+    #   - +max+ -> The max number of desired results
+    # * *Returns* :
+    #   - An updated copy of self
+    # * *Examples* :
+    #    @query.limit(99).options
+    #    => {"$schema"=>"testing", "$query"=>[["$filter", []], ["$limit", 99]]}
     #
+    def limit(max = nil)
+      clone.tap { |r| r.merge_array(["$limit", max]) }
+    end
 
-    # Adds a where clause to the query filter hash
+    # Defines the offset to apply to the query, defaults to nil
     #
-    # Accepts either a Hash or a String
-    #     where(foo: 1)
-    #     where("foo > 1")
+    # * *Args* :
+    #   - +value+ -> The desired offset value
+    # * *Returns* :
+    #   - An updated copy of self
+    # * *Examples* :
+    #    @query.offset(14).options
+    #    => {"$schema"=>"testing", "$query"=>[["$filter", []], ["$offset", 14]]}
     #
-    # Merges a hash:
-    #   { foo: 1 }
+    def offset(value = nil)
+      clone.tap { |r| r.merge_array(["$offset", value]) }
+    end
+
+    # Defines the order clause for the query and merges it into the query array.
+    # See Montage::OrderParser for specifics
+    #
+    # * *Args* :
+    #   - +clause+ -> A hash or string value containing the field to order by
+    #     and the direction.  Valid directions are "asc" and "desc".  String
+    #     values will default to "asc" if omitted or incorrect.
+    # * *Returns* :
+    #   - An updated copy of self
+    # * *Examples* :
+    #   - String
+    #    @query.order("foo asc").options
+    #    => {"$schema"=>"testing", "$query"=>[["$filter", []], ["$order_by", ["$asc", "foo"]]]}
+    #   - Hash
+    #    @query.order(:foo => :asc).options
+    #    => {"$schema"=>"testing", "$query"=>[["$filter", []], ["$order_by", ["$asc", "foo"]]]}
     #
-    # Returns a copy of self
+    def order(clause = {})
+      clone.tap { |r| r.merge_array(OrderParser.new(clause).parse) }
+    end
+
+    # Adds a where clause to the ReQON filter array.  See Montage::QueryParser
+    # for specifics
+    #
+    # * *Args* :
+    #   - +clause+ -> A hash or string containing desired options
+    # * *Returns* :
+    #   - A copy of self
+    # * *Examples* :
+    #   - String
+    #    @query.where("tree_happiness_level >= 99").options
+    #    => {"$schema"=>"test", "$query"=>[["$filter", [["tree_happiness_level", ["$__gte", 99]]]]]}
+    #   - Hash
+    #    @query.where(cloud_type: "almighty").options
+    #    => {"$schema"=>"test", "$query"=>[["$filter", [["cloud_type", "almighty"]]]]}
     #
     def where(clause)
-      clone.tap { |r| r.query[:filter].merge!(QueryParser.new(clause).parse) }
+      clone.tap { |r| r.merge_array(["$filter", QueryParser.new(clause).parse]) }
     end
 
     # Select a set of columns from the result set
     #
+    # * *Args* :
+    #   - +Array+ -> Accepts multiple column names as a string or symbol
+    # * *Example* :
+    #   @query.select("id", "name")
+    #   @query.select(:id, :name)
+    #   => {"$schema"=>"test", "$query"=>[["$filter", []], ["$pluck", ["id", "name"]]]}
+    # * *Returns* :
+    #   - A copy of self
+    #
     def select(*args)
-      clone.tap { |r| r.query.merge!(pluck: args.map(&:to_s))}
+      clone.tap { |r| r.merge_array(["$pluck", args.map(&:to_s)]) }
     end
 
-    # Specifies and index to use on a query. RethinkDB isn't as smart as some other
-    # database engines when selecting a query plan, but it does let you specify
-    # which index to use
+    # Specifies an index to use on a query.
+    #
+    # * *Notes* :
+    #   - RethinkDB isn't as smart as some other database engines when selecting
+    #     a query plan, but it does let you specify which index to use
+    # * *Args* :
+    #   - +field+ -> The index value in string format
+    # * *Example* :
+    #   - @query.index('foo').options
+    #    => {"$schema"=>"test", "$query"=>[["$filter", []], ["$index", "foo"]]}
+    # * *Returns* :
+    #   - A copy of self
     #
     def index(field)
-      clone.tap { |r| r.query.merge!(index: field) }
+      clone.tap { |r| r.merge_array(["$index", field]) }
     end
 
     # Pluck just one column from the result set
     #
+    # * *Args* :
+    #   - +column_name+ -> Accepts a single string or symbol value for the column
+    # * *Example* :
+    #    @query.pluck(:id)
+    #    @query.pluck("id")
+    #    => {"$schema"=>"test", "$query"=>[["$filter", []], ["$pluck", ["id"]]]}
+    # * *Returns* :
+    #   - A copy of self
+    #
     def pluck(column_name)
-      clone.tap { |r| r.query.merge!(pluck: [column_name.to_s]) }
+      clone.tap { |r| r.merge_array(["$pluck", [column_name.to_s]]) }
     end
 
     # Parses the current query hash and returns a JSON string
     #
     def to_json
-      @query.to_json
+      @options.to_json
     end
   end
 end

data/lib/montage/query/order_parser.rb

@@ -0,0 +1,80 @@
+require 'montage/errors'
+
+module Montage
+  class OrderParser
+
+    attr_reader :clause
+
+    # Creates an OrderParser instance based on a clause argument.  The instance
+    # can then be parsed into a valid ReQON string for queries
+    #
+    # * *Args* :
+    #   - +clause+ -> A hash or string ordering value
+    # * *Returns* :
+    #   - A Montage::OrderParser instance
+    # * *Raises* :
+    #   - +ClauseFormatError+ -> If a blank string clause or a hash without
+    #     a valid direction is found.
+    #
+    def initialize(clause)
+      @clause = clause
+      fail(
+        ClauseFormatError, "Order direction missing or blank clause found!"
+      ) unless clause_valid?
+    end
+
+    # Validates clause arguments by checking a hash for a full word match of
+    # "asc" or "desc".  String clauses are rejected if they are blank or
+    # consist entirely of whitespace
+    #
+    # * *Returns* :
+    #   - A boolean
+    #
+    def clause_valid?
+      if @clause.is_a?(Hash)
+        @clause.flatten.find do |e|
+          return true unless (/\basc\b|\bdesc\b/).match(e).nil?
+        end
+      else
+        return true unless @clause.split.empty?
+      end
+    end
+
+    # Parses a hash clause
+    #
+    # * *Returns* :
+    #   - A ReQON formatted array
+    # * *Examples* :
+    #    @clause = { test: "asc"}
+    #    @clause.parse
+    #    => ["$order_by", ["$asc", "test"]]
+    #
+    def parse_hash
+      direction = clause.values.first
+      field = clause.keys.first.to_s
+      ["$order_by", ["$#{direction}", field]]
+    end
+
+    # Parses a string clause, defaults direction to asc if missing or invalid
+    #
+    # * *Returns* :
+    #   - A ReQON formatted array
+    # * *Examples* :
+    #    @clause = "happy_trees desc"
+    #    @clause.parse
+    #    => ["$order_by", ["$desc", "happy_trees"]]
+    #
+    def parse_string
+      direction = clause.split[1]
+      field = clause.split[0]
+      direction = "asc" unless %w(asc desc).include?(direction)
+      ["$order_by", ["$#{direction}", field]]
+    end
+
+    # Determines clause datatype and triggers the correct parsing
+    #
+    def parse
+      @clause.is_a?(Hash) ? parse_hash : parse_string
+    end
+  end
+end

data/lib/montage/query/query_parser.rb

@@ -0,0 +1,205 @@
+require 'montage/errors'
+require 'montage/support'
+require 'json'
+require 'montage/operators'
+
+module Montage
+  class QueryParser
+    include Montage::Support
+
+    attr_reader :query
+
+    TYPE_MAP = {
+      is_i?: :to_i,
+      is_f?: :to_f,
+      is_s?: :to_s
+    }
+
+    # Creates a QueryParser instance based on a query argument.  The instance
+    # can then be parsed into a ReQON compatible array and used as a filter
+    # for queries
+    #
+    # * *Args* :
+    #   - +query+ -> A hash or string that includes the database column name, a
+    #     logical operator, and the associated value
+    # * *Returns* :
+    #   - A Montage::QueryParser instance
+    #
+    def initialize(query)
+      @query = query
+    end
+
+    # Parse the column name from the specific query part
+    #
+    # * *Args* :
+    #   - +part+ -> The query string
+    #   - +splitter+ -> The value to split on
+    # * *Returns* :
+    #   - A string value for the provided column name
+    # * *Examples* :
+    #    @part = "bobross = 'amazing'"
+    #    get_column_name(@part, " ")
+    #    => "bobross"
+    #
+    def get_column_name(part, splitter = " ")
+      part.downcase.split(splitter)[0].strip
+    end
+
+    # Grabs the proper query operator from the string
+    #
+    # * *Args* :
+    #   - +part+ -> The query string
+    # * *Returns* :
+    #   - An array containing the supplied logical operator and the Montage
+    #     equivalent
+    # * *Examples* :
+    #    @part = "tree_happiness_level > 9"
+    #    get_query_operator(@part)
+    #    => [">", "__gt"]
+    #
+    def get_query_operator(part)
+      operator = Montage::Operators.find_operator(part)
+      [operator.operator, operator.montage_operator]
+    end
+
+    # Extract the condition set from the given clause
+    #
+    # * *Args* :
+    #   - +clause+ -> The query string
+    #   - +splitter+ -> The logical operator to split on
+    # * *Returns* :
+    #   - The value portion of the query
+    # * *Examples* :
+    #    @part = "tree_happiness_level > 9"
+    #    parse_condition_set(@part, "<")
+    #    => "9"
+    #
+    def parse_condition_set(clause, splitter = " ")
+      clause.split(/#{splitter}/i)[-1].strip
+    end
+
+    # Parse a single portion of the query string.  String values representing
+    # a float or interger are coerced into actual numerical values.  Newline
+    # characters are removed and single quotes are replaced with double quotes
+    #
+    # * *Args* :
+    #   - +part+ -> The value element extracted from the query string
+    # * *Returns* :
+    #   - A parsed form of the value element
+    # * *Examples* :
+    #    @part = "9"
+    #    parse_part(@part)
+    #    => 9
+    #
+    def parse_part(part)
+      parsed_part = JSON.parse(part) rescue part
+
+      if is_i?(parsed_part)
+        parsed_part.to_i
+      elsif is_f?(parsed_part)
+        parsed_part.to_f
+      elsif parsed_part =~ /\(.*\)/
+        to_array(parsed_part)
+      elsif parsed_part.is_a?(Array)
+        parsed_part
+      else
+        parsed_part.gsub(/('|')/, "")
+      end
+    end
+
+    # Get all the parts of the query string
+    #
+    # * *Args* :
+    #   - +str+ -> The query string
+    # * *Returns* :
+    #   - An array containing the column name, the montage operator, and the
+    #     value for comparison.
+    # * *Raises* :
+    #   - +QueryError+ -> When incomplete queries or queries without valid
+    #     operators are initialized
+    # * *Examples* :
+    #    @part = "tree_happiness_level > 9"
+    #    get_parts(@part)
+    #    => ["tree_happiness_level", "__gt", 9]
+    #
+    def get_parts(str)
+      operator, montage_operator = get_query_operator(str)
+
+      fail QueryError, "Invalid Montage query operator!" unless montage_operator
+
+      column_name = get_column_name(str, operator)
+
+      fail QueryError, "Your query has an undetermined error" unless column_name
+
+      value = parse_part(parse_condition_set(str, operator))
+
+      [column_name, montage_operator, value]
+    end
+
+    # Parse a hash type query
+    #
+    # * *Returns* :
+    #   - A ReQON compatible array
+    # * *Examples* :
+    #    @test = Montage::QueryParser.new(tree_status: "happy")
+    #    @test.parse_hash
+    #    => [["tree_status", "happy"]]
+    #
+    def parse_hash
+      query.map do |key, value|
+        new_key = value.is_a?(Array) ? "#{key}__in" : key
+        ["#{new_key}", value]
+      end
+    end
+
+    # Parse a string type query.  Splits multiple conditions on case insensitive
+    # "and" strings that do not fall within single quotations. Note that the
+    # Montage equals operator is supplied as a blank string
+    #
+    # * *Returns* :
+    #   - A ReQON compatible array
+    # * *Examples* :
+    #    @test = Montage::QueryParser.new("tree_happiness_level > 9")
+    #    @test.parse_string
+    #    => [["tree_happiness_level", ["$__gt", 9]]]
+    #
+    def parse_string
+      query.split(/\band\b(?=(?:[^']|'[^']*')*$)/i).map do |part|
+        column_name, operator, value = get_parts(part)
+        if operator == ""
+          ["#{column_name}", value]
+        else
+          ["#{column_name}", ["$#{operator}", value]]
+        end
+      end
+    end
+
+    # Determines query datatype and triggers the correct parsing
+    #
+    def parse
+      if query.is_a?(Hash)
+        parse_hash
+      else
+        parse_string
+      end
+    end
+
+    # Takes a string value and splits it into an array
+    # Will coerce all values into the type of the first type
+    #
+    # * *Args* :
+    #   - +value+ -> A string value
+    # * *Returns* :
+    #   - A array form of the value argument
+    # * *Examples* :
+    #    @part = "(1, 2, 3)"
+    #    to_array(@part)
+    #    => [1, 2, 3]
+    #
+    def to_array(value)
+      values = value.gsub(/('|\(|\))/, "").split(',')
+      type = [:is_i?, :is_f?].find(Proc.new { :is_s? }) { |t| send(t, values.first) }
+      values.map { |v| v.send(TYPE_MAP[type]) }
+    end
+  end
+end

data/lib/montage/version.rb

@@ -1,3 +1,3 @@
 module Montage
-  VERSION = "0.5.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-montage
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 1.0.0
 platform: ruby
 authors:
 - dphaener
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-04 00:00:00.000000000 Z
+date: 2016-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -214,7 +214,8 @@ files:
 - lib/montage/operators/not.rb
 - lib/montage/operators/not_in.rb
 - lib/montage/query.rb
-- lib/montage/query_parser.rb
+- lib/montage/query/order_parser.rb
+- lib/montage/query/query_parser.rb
 - lib/montage/resource.rb
 - lib/montage/resources.rb
 - lib/montage/resources/document.rb

data/lib/montage/query_parser.rb

@@ -1,116 +0,0 @@
-require 'montage/errors'
-require 'montage/support'
-require 'json'
-require 'montage/operators'
-
-module Montage
-  class QueryParser
-    include Montage::Support
-
-    attr_reader :query
-
-    TYPE_MAP = {
-      is_i?: :to_i,
-      is_f?: :to_f,
-      is_s?: :to_s
-    }
-
-    def initialize(query)
-      @query = query
-    end
-
-    # Parse the column name from the specific query part
-    #
-    def get_column_name(part, splitter = " ")
-      part.downcase.split(splitter)[0].strip
-    end
-
-    # Grabs the proper query operator from the string
-    #
-    def get_query_operator(part)
-      operator = Montage::Operators.find_operator(part)
-      [operator.operator, operator.montage_operator]
-    end
-
-    # Extract the condition set from the given clause
-    #
-    def parse_condition_set(clause, splitter = " ")
-      clause.split(/#{splitter}/i)[-1].strip
-    end
-
-    # Parse a single portion of the query string
-    #
-    def parse_part(part)
-      parsed_part = JSON.parse(part) rescue part
-
-      if is_i?(parsed_part)
-        parsed_part.to_i
-      elsif is_f?(parsed_part)
-        parsed_part.to_f
-      elsif parsed_part =~ /\(.*\)/
-        to_array(parsed_part)
-      elsif parsed_part.is_a?(Array)
-        parsed_part
-      else
-        parsed_part.gsub(/('|')/, "")
-      end
-    end
-
-    # Get all the parts of the query string
-    #
-    def get_parts(str)
-      operator, montage_operator = get_query_operator(str)
-
-      raise QueryError, "The operator you have used is not a valid Montage query operator" unless montage_operator
-
-      column_name = get_column_name(str, operator)
-
-      raise QueryError, "Your query has an undetermined error" unless column_name
-
-      value = parse_part(parse_condition_set(str, operator))
-
-      [column_name, montage_operator, value]
-    end
-
-    # Parse a hash type query
-    #
-    def parse_hash
-      Hash[
-        query.map do |key, value|
-          new_key = value.is_a?(Array) ? "#{key}__in".to_sym : key
-          [new_key, value]
-        end
-      ]
-    end
-
-    # Parse a string type query
-    #
-    def parse_string
-      Hash[
-        query.split(/\band\b(?=([^']*'[^']*')*[^']*$)/i).map do |part|
-          column_name, operator, value = get_parts(part)
-          ["#{column_name}#{operator}".to_sym, value]
-        end
-      ]
-    end
-
-    # Parse the clause into a Montage query
-    #
-    def parse
-      if query.is_a?(Hash)
-        parse_hash
-      else
-        parse_string
-      end
-    end
-
-    # Takes a string value and splits it into an array
-    # Will coerce all values into the type of the first type
-    #
-    def to_array(value)
-      values = value.gsub(/('|\(|\))/, "").split(',')
-      type = [:is_i?, :is_f?].find(Proc.new { :is_s? }) { |t| send(t, values.first) }
-      values.map { |v| v.send(TYPE_MAP[type]) }
-    end
-  end
-end