contentstack 0.0.2

data/lib/contentstack/entry.rb

@@ -0,0 +1,27 @@
+module Contentstack
+  class Entry
+    attr_reader :fields, :content_type, :uid, :owner
+    def initialize(attrs, content_type_uid=nil)
+      setup(attrs, content_type_uid)
+    end
+
+    def fetch
+      entry = API.fetch_entry(@content_type, self.fields[:uid])
+      setup(entry["entry"])
+      self
+    end
+
+    def get(field_uid)
+      raise Contentstack::Error("Please send a valid Field UID") if field_uid.class != String
+      @fields[field_uid.to_sym]
+    end
+
+    private
+    def setup(attrs, content_type_uid=nil)
+      @fields       = attrs.symbolize_keys
+      @content_type = content_type_uid if !content_type_uid.blank?
+      @owner        = attrs[:_owner] if attrs[:_owner]
+      @uid          = attrs[:uid]
+    end
+  end
+end

data/lib/contentstack/entry_collection.rb

@@ -0,0 +1,43 @@
+require 'contentstack/entry'
+
+module Contentstack
+  class EntryCollection
+    attr_reader :entries, :count, :content_type, :schema
+
+    def initialize(json, content_type_uid=nil)
+      @count        = json["count"] if json["count"]
+      @entries      = json["entries"].collect{|entry| Entry.new(entry, content_type_uid) }
+      @schema       = json["schema"].symbolize_keys if json["schema"]
+      @content_type = json["content_type"].symbolize_keys if json["content_type"]
+      self
+    end
+
+    def each &block
+      @entries.map{|e| block.call(e)}
+    end
+
+    def map &block
+      self.each(&block)
+    end
+
+    def collect &block
+      self.each(&block)
+    end
+
+    def length
+      @entries.length
+    end
+
+    def first
+      @entries.first
+    end
+
+    def last
+      @entries.last
+    end
+
+    def get(index)
+      @entries[index]
+    end
+  end
+end

data/lib/contentstack/error.rb

@@ -0,0 +1,7 @@
+module Contentstack
+  class Error < StandardError
+    def initialize(msg="Something Went Wrong.")
+      super
+    end
+  end
+end

data/lib/contentstack/query.rb

@@ -0,0 +1,589 @@
+require 'contentstack/entry_collection'
+
+module Contentstack
+  # A class that defines a query that is used to query for Entry instance.
+  class Query
+    # @!attribute [r] query
+    #   Attribute which has all the information about the query which will be executed against Contentstack API
+
+    # @!attribute [r] content_type
+    #   Denotes which `content_type` should the query be executed for
+
+    attr_reader :query, :content_type
+
+    # Initialize the Query instance
+    # @param [String] content_type
+    #
+    # Example:
+    #    @query   = @stack.content_type('blog').query
+    #    @entries = @query.where('author', 'John Doe').fetch
+    #
+    # @return [Contentstack::Query]
+    def initialize(content_type)
+      @content_type = content_type
+      @query = {
+        query: "{}",
+        include_count: false,
+        skip: 0,
+        count: 10,
+        desc: 'created_at'
+      }
+    end
+
+    # Add a custom query against specified key.
+    # @param [String] field_uid
+    # @param [String/Number/Boolean/Hash] value
+    #
+    # Example:
+    #    @query   = @stack.content_type('blog').query
+    #    @query.add_query('author', "Jane Doe")
+    #
+    # @return [Contentstack::Query]
+    def add_query(field_uid, value)
+      add_query_hash({:"#{field_uid}" => value})
+    end
+
+    # Remove provided query key from custom query if exist.
+    # @param [String] field_uid
+    #
+    # Example:
+    #    @query   = @stack.content_type('blog').query
+    #    @query.remove_query('author')
+    #
+    # @return [Contentstack::Query]
+    def remove_query(field_uid)
+      q = ActiveSupport::JSON.decode(@query[:query])
+      q.delete(field_uid)
+      @query[:query] = ActiveSupport::JSON.encode(q)
+      self
+    end
+
+    # Add a constraint to fetch all entries that contains given value against specified key.
+    # @param [Hash] query_hash
+    #
+    # Example:
+    #    @query = @stack.content_type('blog').query
+    #    @query.where({:author => "Jane Doe"})
+    #
+    # @return [Contentstack::Query]
+    def where(query_hash)
+      add_query_hash(query_hash)
+    end
+
+    # Add a regular expression constraint for finding string values that match the provided regular expression. This may be slow for large data sets.
+    # @param [String] field_uid  The key to be constrained.
+    # @param [String] pattern  The regular expression pattern to match.
+    # @param [String] options  Regex options
+    #
+    # Example:
+    #    @query = @stack.content_type('product').query
+    #    @query.regex('title', '.*Mobile.*', 'i') # Search without case sensitivity
+    #
+    # @return [Contentstack::Query]
+    def regex(field_uid, pattern, options="")
+      hash = {
+        "#{field_uid}" => {
+          "$regex": pattern
+        }
+      }
+
+      hash["#{field_uid}"]["$options"] = options if !options.empty? || !options.nil?
+
+      add_query_hash(hash)
+    end
+
+    # Add a constraint that requires, a specified key exists in response.
+    # @param [String] field_uid The key to be constrained.
+    #
+    # Example:
+    #    @query = @stack.content_type('product').query
+    #    @query.exists?('product_image') # only fetch products which have a `product_image`
+    #
+    # @return [Contentstack::Query]
+    def exists?(field_uid)
+      add_query_hash({:"#{field_uid}" => {"$exists" => true}})
+    end
+
+    # Add a constraint that requires, a specified key does not exists in response.
+    # @param [String] field_uid The key to be constrained.
+    #
+    # Example:
+    #    @query = @stack.content_type('product').query
+    #    @query.not_exists?('product_image') # only fetch products which do not have a `product_image`
+    #
+    # @return [Contentstack::Query]
+    def not_exists?(field_uid)
+      add_query_hash({:"#{field_uid}" => {"$exists" => false}})
+      self
+    end
+
+    # Combines all the queries together using AND operator.
+    #
+    # @param [Array] queries  Array of instances of the Query class
+    #
+    # Each query should be an instance of the Contentstack::Query class, and belong to the same `content_type`
+    # Example:
+    #    @query1 = @stack.content_type('category').query
+    #    @query1.where('title', 'Electronics')
+    # 
+    #    @query2 = @stack.content_type('category').query
+    #    @query2.regex('description', '.*Electronics.*')
+    #
+    #    query_array = [@query1, @query2]
+    #
+    #    @query = @stack.content_type('category').query
+    #    @query.and(query_array)
+    #
+    # @return [Contentstack::Query]
+    def and(queries)
+      add_query_hash({"$and" => concat_queries(queries)})
+      self
+    end
+
+    # Combines all the queries together using OR operator.
+    #
+    # @param [Array] queries  Array of instances of the Query class
+    #
+    # Each query should be an instance of the Contentstack::Query class, and belong to the same `content_type`
+    # Example:
+    #    @query1 = @stack.content_type('category').query
+    #    @query1.where('title', 'Electronics')
+    # 
+    #    @query2 = @stack.content_type('category').query
+    #    @query2.where('title', 'Apparel')
+    #
+    #    query_array = [@query1, @query2]
+    #
+    #    @query = @stack.content_type('category').query
+    #    @query.or(query_array)
+    #
+    # @return [Contentstack::Query]
+    def or(queries)
+      add_query_hash({"$or" => concat_queries(queries)})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key entry to be less than the provided value.
+    #
+    # @param [String] field_uid  UID of the field for which query should be executed
+    # 
+    # @param [String/Number] value  Value that provides an upper bound
+    # 
+    # Example
+    #    @query = @stack.content_type('product').query
+    #    @query.less_than('price', '100')
+    #
+    # @return [Contentstack::Query]
+    def less_than(field_uid, value)
+      add_query_hash({:"#{field_uid}" => {"$lt" => value}})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key entry to be less than or equal to the provided value.
+    #
+    # @param [String] field_uid  UID of the field for which query should be executed
+    # 
+    # @param [String/Number] value  Value that provides an upper bound
+    # 
+    # Example
+    #    @query = @stack.content_type('product').query
+    #    @query.less_than_or_equal('price', '100')
+    #
+    # @return [Contentstack::Query]
+    def less_than_or_equal(field_uid, value)
+      add_query_hash({:"#{field_uid}" => {"$lte" => value}})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key entry to be greater than the provided value.
+    #
+    # @param [String] field_uid  UID of the field for which query should be executed
+    # 
+    # @param [String/Number] value  Value that provides a lower bound
+    # 
+    # Example
+    #    @query = @stack.content_type('product').query
+    #    @query.greater_than('price', '100')
+    #
+    # @return [Contentstack::Query]
+    def greater_than(field_uid, value)
+      add_query_hash({:"#{field_uid}" => {"$gt" => value}})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key entry to be greater than or equal to the provided value.
+    #
+    # @param [String] field_uid UID of the field for which query should be executed
+    # 
+    # @param [String/Number] value Value that provides a lower bound
+    # 
+    # Example
+    #    @query = @stack.content_type('product').query
+    #    @query.greater_than_or_equal('price', '100')
+    #
+    # @return [Contentstack::Query]
+    def greater_than_or_equal(field_uid, value)
+      add_query_hash({:"#{field_uid}" => {"$gte" => value}})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key's entry to be not equal to the provided value.
+    #
+    # @param [String] field_uid UID of the field for which query should be executed
+    # @param [String] value The object that must not be equaled.
+    #
+    # Example
+    #    @query = @stack.content_type('product').query
+    #    @query.not_equal_to('price', '100')
+    #
+    # @return [Contentstack::Query]
+    def not_equal_to(field_uid, value)
+      add_query_hash({:"#{field_uid}" => {"$ne" => value}})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key's entry to be contained in the provided array.
+    #
+    # @param [String] field_uid UID of the field for which query should be executed
+    # @param [String] values The possible values for the key's object
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.contained_in("title", ["Electronics", "Apparel"])
+    #
+    # @return [Contentstack::Query]
+    def contained_in(field_uid, values)
+      add_query_hash({:"#{field_uid}" => {"$in" => values}})
+      self
+    end
+
+    # Add a constraint to the query that requires a particular key entry's value not be contained in the provided array.
+    #
+    # @param [String] field_uid UID of the field for which query should be executed
+    # @param [String] values The possible values for the key's object
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.not_contained_in("title", ["Electronics", "Apparel"])
+    #
+    # @return [Contentstack::Query]
+    def not_contained_in(field_uid, values)
+      add_query_hash({:"#{field_uid}" => {"$nin" => values}})
+      self
+    end
+
+    # The number of objects to skip before returning any.
+    #
+    # @param [Number] count of objects to skip from resulset.
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.skip(50)
+    #
+    # @return [Contentstack::Query]
+    def skip(count)
+      @query[:skip] = count
+      self
+    end
+
+    # This method provides only the entries matching the specified value.
+    #
+    # @param [String] text value used to match or compare
+    #
+    # Example
+    #    @query = @stack.content_type('product').query
+    #    @query.search("This is an awesome product")
+    #
+    # @return [Contentstack::Query]
+    def search(text)
+      @query[:typeahead] = text
+      self
+    end
+
+    # A limit on the number of objects to return.
+    #
+    # @param [Number] count of objects to limit in resulset.
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.limit(50)
+    #
+    # @return [Contentstack::Query]
+    def limit(count=10)
+      @query[:limit] = count
+      self
+    end
+
+    # Retrieve only count of entries in result.
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.count
+    #
+    # @return [Integer]
+    def count
+      include_count
+      fetch.count
+    end
+
+    # Retrieve count and data of objects in result.
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.include_count
+    #
+    # @return [Contentstack::Query]
+    def include_count(flag=true)
+      @query[:include_count] = flag
+      self
+    end
+
+    # Sort the results in ascending order with the given key. 
+    # Sort the returned entries in ascending order of the provided key.
+    #
+    # @param [String] field_uid The key to order by
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.ascending
+    #
+    # @return [Contentstack::Query]
+    def ascending(field_uid)
+      @query.delete(:desc)
+      @query[:asc] = field_uid
+      self
+    end
+
+    # Sort the results in descending order with the given key. 
+    # Sort the returned entries in descending order of the provided key.
+    #
+    # @param [String] field_uid The key to order by
+    #
+    # Example
+    #    @query = @stack.content_type('category').query
+    #    @query.descending
+    #
+    # @return [Contentstack::Query]
+    def descending(field_uid)
+      @query.delete(:asc)
+      @query[:desc] = field_uid
+      self
+    end
+
+    # Specifies an array of 'only' keys in BASE object that would be 'included' in the response.
+    #
+    # @param [Array] fields Array of the 'only' reference keys to be included in response.
+    # @param [Array] fields_with_base Can be used to denote 'only' fields of the reference class
+    #
+    # Example
+    #    # Include only title and description field in response
+    #    @query = @stack.content_type('category').query
+    #    @query.only(['title', 'description'])
+    #
+    #    # Query product and include only the title and description from category reference
+    #    @query = @stack.content_type('product').query
+    #    @query.include_reference('category')
+    #          .only('category', ['title', 'description'])
+    #
+    # @return [Contentstack::Query]
+    def only(fields, fields_with_base=nil)
+      q = {}
+      if [Array, String].include?(fields_with_base.class)
+        fields_with_base = [fields_with_base] if fields_with_base.class == String
+        q[fields.to_sym] = fields_with_base
+      else
+        fields = [fields] if fields.class == String
+        q = {BASE: fields}
+      end
+
+      @query[:only] = q
+      self
+    end
+
+    # Specifies list of field uids that would be 'excluded' from the response.
+    #
+    # @param [Array] fields Array of field uid which get 'excluded' from the response.
+    # @param [Array] fields_with_base Can be used to denote 'except' fields of the reference class
+    #
+    # Example
+    #    # Exclude 'description' field in response
+    #    @query = @stack.content_type('category').query
+    #    @query.except(['description'])
+    #
+    #    # Query product and exclude the 'description' from category reference
+    #    @query = @stack.content_type('product').query
+    #    @query.include_reference('category')
+    #          .except('category', ['description'])
+    #
+    # @return [Contentstack::Query]
+    def except(fields, fields_with_base=nil)
+      q = {}
+      if [Array, String].include?(fields_with_base.class)
+        fields_with_base = [fields_with_base] if fields_with_base.class == String
+        q[fields.to_sym] = fields_with_base
+      else
+        fields = [fields] if fields.class == String
+        q = {BASE: fields}
+      end
+
+      @query[:except] = q
+      self
+    end
+
+    # Add a constraint that requires a particular reference key details.
+    #
+    # @param [String/Array] reference_field_uids Pass string or array of reference fields that must be included in the response
+    #
+    # Example
+    #
+    #    # Include reference of 'category'
+    #    @query = @stack.content_type('product').query
+    #    @query.include_reference('category')
+    #
+    #    # Include reference of 'category' and 'reviews'
+    #    @query = @stack.content_type('product').query
+    #    @query.include_reference(['category', 'reviews'])
+    #
+    # @return [Contentstack::Query]
+    def include_reference(reference_field_uids)
+      self.include(reference_field_uids)
+    end
+
+    # Include schemas of all returned objects along with objects themselves.
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.include_schema
+    #
+    # @return [Contentstack::Query]
+    def include_schema(flag=true)
+      @query[:include_schema] = flag
+      self
+    end
+
+    # Include object owner's profile in the objects data.
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.include_owner
+    #
+    # @return [Contentstack::Query]
+    def include_owner(flag=true)
+      @query[:include_owner] = flag
+      self
+    end
+
+    # Include object's content_type in response
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.include_content_type
+    #
+    # @return [Contentstack::Query]
+    def include_content_type(flag=true)
+      @query[:include_content_type] = flag
+      self
+    end
+
+    # Include objects in 'Draft' mode in response
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.include_draft
+    #
+    # @return [Contentstack::Query]
+    def include_draft(flag=true)
+      @query[:include_draft] = flag
+      self
+    end
+
+
+    #
+    # @return [Contentstack::Query]
+    def include(field_uids)
+      field_uids = [field_uids] if field_uids.class == String
+      @query[:include] ||= []
+      @query[:include] = @query[:include] | field_uids
+      self
+    end
+
+    # Include tags with which to search entries.
+    #
+    # @param [Array] tags_array Array of tags using which search must be performed
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.tags(["tag1", "tag2"])
+    #
+    # @return [Contentstack::Query]
+    def tags(tags_array)
+      @query[:tags] = tags_array
+      self
+    end
+
+
+    # Execute query
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.tags(["tag1", "tag2"])
+    #          .fetch
+    #
+    # @return [Contentstack::EntryCollection]
+    def fetch
+      entries = API.fetch_entries(@content_type, @query)
+      EntryCollection.new(entries, @content_type)
+    end
+
+    # Execute a Query and get the single matching object
+    #
+    # Example
+    #
+    #    @query = @stack.content_type('product').query
+    #    @query.tags(["tag1", "tag2"])
+    #          .find_one
+    #
+    # @return [Contentstack::Entry]
+    def find_one
+      limit 1
+      fetch.first
+    end
+
+    alias_method :find, :fetch
+    alias_method :in, :contained_in
+    alias_method :not_in, :not_contained_in
+
+    private
+    def add_query_hash(query_hash)
+      q = ActiveSupport::JSON.decode(@query[:query])
+      q.merge!(query_hash)
+      @query[:query] = ActiveSupport::JSON.encode(q)
+      self
+    end
+
+    def concat_queries(queries)
+      this_queries = []
+      this_query = ActiveSupport::JSON.decode(@query[:query])
+      if this_query.keys.length > 0
+        this_queries = [this_query]
+      end
+
+      if queries.class == Array
+        queries.map do |query_object|
+          if query_object.class == Contentstack::Query && query_object.content_type == @content_type
+            q = ActiveSupport::JSON.decode(query_object.query[:query])
+            this_queries.push(q.symbolize_keys)
+          end
+        end
+      end
+
+      this_queries
+    end
+  end
+end