From 1e43784cc2fa6585f0c6ce7265bd54156b00aeaa Mon Sep 17 00:00:00 2001 From: Thomas Reynolds Date: Mon, 28 Apr 2014 10:28:16 -0700 Subject: [PATCH] remove queryable api --- CHANGELOG.md | 1 + middleman-core/features/queryable.feature | 35 ---- .../step_definitions/queryable_steps.rb | 135 --------------- .../lib/middleman-core/sitemap/queryable.rb | 155 ------------------ .../lib/middleman-core/sitemap/store.rb | 3 - 5 files changed, 1 insertion(+), 328 deletions(-) delete mode 100644 middleman-core/features/queryable.feature delete mode 100644 middleman-core/features/step_definitions/queryable_steps.rb delete mode 100644 middleman-core/lib/middleman-core/sitemap/queryable.rb diff --git a/CHANGELOG.md b/CHANGELOG.md index 31e38c34..5cbd238b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ master === +* Removed Queryable Sitemap API * Removed `css_compressor` setting, use `activate :minify_css, :compressor =>` instead. * Removed `js_compressor` setting, use `activate :minify_javascript, :compressor =>` instead. * Removed ability to server folders of content statically (non-Middleman projects). diff --git a/middleman-core/features/queryable.feature b/middleman-core/features/queryable.feature deleted file mode 100644 index 1382db3f..00000000 --- a/middleman-core/features/queryable.feature +++ /dev/null @@ -1,35 +0,0 @@ -Feature: Queryable Selector - Scenario: Basic Selector Tests - Then should initialize with an attribute and an operator - Then should raise an exception if the operator is not supported - Scenario: Using offset and limit - Given the Server is running at "queryable-app" - Then should limit the documents to the number specified - Then should offset the documents by the number specified - Then should support offset and limit at the same time - Then should not freak out about an offset higher than the document count - Scenario: Using where queries with an equal operator - Given the Server is running at "queryable-app" - Then should return the right documents - Then should be chainable - Then should not be confused by attributes not present in all documents - Scenario: Using where queries with a complex operator - Given the Server is running at "queryable-app" - Then with a gt operator should return the right documents - Then with a gte operator should return the right documents - Then with an in operator should return the right documents - Then with an lt operator should return the right documents - Then with an lte operator should return the right documents - Then with an include operator include should return the right documents - Then with mixed operators should return the right documents - Then using multiple constrains in one where should return the right documents - Scenario: Sorting documents - Given the Server is running at "queryable-app" - Then should support ordering by attribute ascending - Then should support ordering by attribute descending - Then should order by attribute ascending by default - Then should exclude documents that do not own the attribute - Scenario: Passing queries around - Given a simple 'where' query - When I chain a where clause onto that query - Then the original query should remain unchanged diff --git a/middleman-core/features/step_definitions/queryable_steps.rb b/middleman-core/features/step_definitions/queryable_steps.rb deleted file mode 100644 index 995c3d33..00000000 --- a/middleman-core/features/step_definitions/queryable_steps.rb +++ /dev/null @@ -1,135 +0,0 @@ -Given /^a simple 'where' query$/ do - @query = Middleman::Sitemap::Queryable::Query.new({}).where(:foo => 'bar') -end - -When /^I chain a where clause onto that query$/ do - @new_query = @query.where(:baz => 'foo') -end - -Then /^the original query should remain unchanged$/ do - @query.opts({}).should_not eql @new_query.opts({}) -end - -Then /^should initialize with an attribute and an operator$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :author, :operator => 'equal' - :author.should == selector.attribute - 'equal'.should == selector.operator -end - -Then /^should raise an exception if the operator is not supported$/ do - expect { - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :author, :operator => 'zomg' - }.to raise_error(::Middleman::Sitemap::Queryable::OperatorNotSupportedError) -end - -Then /^should limit the documents to the number specified$/ do - @server_inst.sitemap.order_by(:id).limit(2).all.map { |r| r.raw_data[:id] }.sort.should == [1,2].sort -end - -Then /^should offset the documents by the number specified$/ do - @server_inst.sitemap.order_by(:id).offset(2).all.map { |r| r.raw_data[:id] }.sort.should == [3,4,5].sort -end - -Then /^should support offset and limit at the same time$/ do - @server_inst.sitemap.order_by(:id).offset(1).limit(2).all.map { |r| r.raw_data[:id] }.sort.should == [2,3].sort -end - -Then /^should not freak out about an offset higher than the document count$/ do - @server_inst.sitemap.order_by(:id).offset(5).all.should == [] -end - -Then /^should return the right documents$/ do - documents = @server_inst.sitemap.resources.select { |r| !r.raw_data.empty? } - document_1 = documents[0] - document_2 = documents[1] - - found_document = @server_inst.sitemap.where(:title => document_1.raw_data[:title]).first - document_1.should == found_document - - found_document = @server_inst.sitemap.where(:title => document_2.raw_data[:title]).first - document_2.should == found_document -end - -Then /^should be chainable$/ do - documents = @server_inst.sitemap.resources.select { |r| !r.raw_data.empty? } - document_1 = documents[0] - - document_proxy = @server_inst.sitemap.where(:title => document_1.raw_data[:title]) - document_proxy.where(:id => document_1.raw_data[:id]) - document_1.should == document_proxy.first -end - -Then /^should not be confused by attributes not present in all documents$/ do - result = @server_inst.sitemap.where(:seldom_attribute => 'is seldom').all - result.map { |r| r.raw_data[:id] }.should == [4] -end - -Then /^with a gt operator should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'gt' - found_documents = @server_inst.sitemap.where(selector => 2).all - found_documents.map { |r| r.raw_data[:id] }.sort.should == [5,3,4].sort -end - -Then /^with a gte operator should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'gte' - found_documents = @server_inst.sitemap.where(selector => 2).all - found_documents.map { |r| r.raw_data[:id] }.sort.should == [2,5,3,4].sort -end - -Then /^with an in operator should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'in' - found_documents = @server_inst.sitemap.where(selector => [2,3]).all - found_documents.map { |r| r.raw_data[:id] }.sort.should == [2,3].sort -end - -Then /^with an lt operator should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'lt' - found_documents = @server_inst.sitemap.where(selector => 2).all - found_documents.map { |r| r.raw_data[:id] }.should == [1] -end - -Then /^with an lte operator should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'lte' - found_documents = @server_inst.sitemap.where(selector => 2).all - found_documents.map { |r| r.raw_data[:id] }.sort.should == [1,2].sort -end - -Then /^with an include operator include should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :tags, :operator => 'include' - found_documents = @server_inst.sitemap.where(selector => 'ruby').all - found_documents.map { |r| r.raw_data[:id] }.sort.should == [1,2].sort -end - -Then /^with mixed operators should return the right documents$/ do - in_selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'in' - gt_selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'gt' - documents_proxy = @server_inst.sitemap.where(in_selector => [2,3]) - found_documents = documents_proxy.where(gt_selector => 2).all - found_documents.map { |r| r.raw_data[:id] }.should == [3] -end - -Then /^using multiple constrains in one where should return the right documents$/ do - selector = ::Middleman::Sitemap::Queryable::Selector.new :attribute => :id, :operator => 'lte' - found_documents = @server_inst.sitemap.where(selector => 2, :status => :published).all - found_documents.map { |r| r.raw_data[:id] }.sort.should == [1,2].sort -end - -Then /^should support ordering by attribute ascending$/ do - found_documents = @server_inst.sitemap.order_by(:title => :asc).all - found_documents.map { |r| r.raw_data[:id] }.should == [2,3,1,5,4] -end - -Then /^should support ordering by attribute descending$/ do - found_documents = @server_inst.sitemap.order_by(:title => :desc).all - found_documents.map { |r| r.raw_data[:id] }.should == [4,5,1,3,2] -end - -Then /^should order by attribute ascending by default$/ do - found_documents = @server_inst.sitemap.order_by(:title).all - found_documents.map { |r| r.raw_data[:id] }.should == [2,3,1,5,4] -end - -Then /^should exclude documents that do not own the attribute$/ do - found_documents = @server_inst.sitemap.order_by(:status).all - found_documents.map { |r| r.raw_data[:id] }.to_set.should == [1,2].to_set -end diff --git a/middleman-core/lib/middleman-core/sitemap/queryable.rb b/middleman-core/lib/middleman-core/sitemap/queryable.rb deleted file mode 100644 index aab8be4e..00000000 --- a/middleman-core/lib/middleman-core/sitemap/queryable.rb +++ /dev/null @@ -1,155 +0,0 @@ -require 'active_support/core_ext/object/inclusion' - -module Middleman - module Sitemap - - # Code adapted from https://github.com/ralph/document_mapper/ - module Queryable - OPERATOR_MAPPING = { - 'equal' => :==, - 'gt' => :>, - 'gte' => :>=, - 'in' => :in?, - 'include' => :include?, - 'lt' => :<, - 'lte' => :<= - } - - VALID_OPERATORS = OPERATOR_MAPPING.keys - - FileNotFoundError = Class.new StandardError - OperatorNotSupportedError = Class.new StandardError - - module API - def select(options = {}) - documents = resources.select { |r| !r.raw_data.empty? } - options[:where].each do |selector, selector_value| - documents = documents.select do |document| - next unless document.raw_data.has_key? selector.attribute - document_value = document.raw_data[selector.attribute] - operator = OPERATOR_MAPPING[selector.operator] - document_value.send operator, selector_value - end - end - - if options[:order_by].present? - order_attribute = options[:order_by].keys.first - asc_or_desc = options[:order_by].values.first - documents = documents.select do |document| - document.raw_data.include? order_attribute - end - documents = documents.sort_by do |document| - document.raw_data[order_attribute] - end - documents.reverse! if asc_or_desc == :desc - end - - documents - end - - def where(hash) - Query.new(self).where(hash) - end - - def order_by(field) - Query.new(self).order_by(field) - end - - def offset(number) - Query.new(self).offset(number) - end - - def limit(number) - Query.new(self).limit(number) - end - end - - class Query - def initialize(model, opts={}) - @model = model - @where = opts[:where] || {} - @order_by = opts[:order_by] - @offset = opts[:offset] - @limit = opts[:limit] - end - - def where(constraints_hash) - selector_hash = constraints_hash.reject { |key, value| !key.is_a? Selector } - symbol_hash = constraints_hash.reject { |key, value| key.is_a? Selector } - symbol_hash.each do |attribute, value| - selector = Selector.new(:attribute => attribute, :operator => 'equal') - selector_hash.update({ selector => value }) - end - Query.new @model, opts(:where => @where.merge(selector_hash)) - end - - def opts new_opts - { :where => {}.merge(@where), - :order_by => @order_by, - :offset => @offset, - :limit => @limit - }.merge(new_opts) - end - - def order_by(field) - Query.new @model, opts(:order_by => field.is_a?(Symbol) ? {field => :asc} : field) - end - - def offset(number) - Query.new @model, opts(:offset => number) - end - - def limit(number) - Query.new @model, opts(:limit => number) - end - - def first - self.all.first - end - - def last - self.all.last - end - - def all - result = @model.select(:where => @where, :order_by => @order_by) - if @offset.present? - result = result.last([result.size - @offset, 0].max) - end - if @limit.present? - result = result.first(@limit) - end - result - end - end - - class Selector - attr_reader :attribute, :operator - - def initialize(opts = {}) - unless VALID_OPERATORS.include? opts[:operator] - raise OperatorNotSupportedError - end - @attribute, @operator = opts[:attribute], opts[:operator] - end - end - end - end -end - -# Add operators to symbol objects -class Symbol - Middleman::Sitemap::Queryable::VALID_OPERATORS.each do |operator| - class_eval <<-OPERATORS - def #{operator} - Middleman::Sitemap::Queryable::Selector.new(:attribute => self, :operator => '#{operator}') - end - OPERATORS - end - - unless method_defined?(:"<=>") - def <=>(other) - self.to_s <=> other.to_s - end - end -end diff --git a/middleman-core/lib/middleman-core/sitemap/store.rb b/middleman-core/lib/middleman-core/sitemap/store.rb index 217fa6c3..be067c04 100644 --- a/middleman-core/lib/middleman-core/sitemap/store.rb +++ b/middleman-core/lib/middleman-core/sitemap/store.rb @@ -1,7 +1,6 @@ # Used for merging results of metadata callbacks require 'active_support/core_ext/hash/deep_merge' require 'monitor' -require 'middleman-core/sitemap/queryable' # Extensions require 'middleman-core/sitemap/extensions/on_disk' @@ -26,8 +25,6 @@ module Middleman # @return [Middleman::Application] attr_accessor :app - include ::Middleman::Sitemap::Queryable::API - # Initialize with parent app # @param [Middleman::Application] app def initialize(app)