morse_searchable 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0450f80c82d494d57e0865164277650333f26d54
+  data.tar.gz: ac55b0a7cffbc674b3142f9c90169cafe10147b4
+SHA512:
+  metadata.gz: 1c08f099e2dd41f0d017807c5ddc56d38eda31139bb6f744f22a5ff319877d7b28250de75ed894c65a443c7bede7e6ffc06aafe0d73d9447b8735f1badc3a769
+  data.tar.gz: 235a99dd6117dfce4b88e33c0de78ff3e96bc74f51c3c1dad06b3aaad004215b5ec33fcdac3f269af9e4b8c05a33b2570aa559ab977d07e22ea8c3425c020e26

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 fredmcgroarty
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= MorseSearchable
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MorseSearchable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/controllers/concerns/searchable.rb

@@ -0,0 +1,126 @@
+module Searchable
+
+  ACCEPTED_INPUT_TYPES = [:select, :checkbox, :radio]
+
+  extend ActiveSupport::Concern
+  #current defects - possibly issue handling non validated association fields
+                    #not set up to use has many yet
+
+  DEFAULT_FIELDS = [:id]
+
+  def feed
+    respond_to do |format|
+      if sanitized_klass
+        format.json { render 'api/search/feed', layout: false, locals: { feed: data_pool, fields: attributes } }
+      else
+        format.json { render :json => {:error => "Check module configuration settings"}, status: 404 }
+      end
+    end
+  end
+
+  def filters
+    respond_to do |format|
+      if sanitized_filters
+        format.json { render 'api/search/filters', layout: false, locals: { filters: build_filters } }
+      else
+        format.json { render :json => {:error => "Check module configuration settings"}, status: 404 }
+      end
+    end
+  end
+
+  private
+
+  def apply_scope
+    operable_klass.send(sanitized_klass[:scope])
+  end
+
+  def attributes
+    association_fields = {}
+    association_fields[:main] = sanitized_klass[:attributes]
+    sanitized_filters.each do |obj,attrs|
+      association = klass_to_symbol(obj)
+      if sanitized_klass[:klass].new.respond_to?(association)
+        arr=attrs.select { |atr| atr unless DEFAULT_FIELDS.include?(atr) }
+        association_fields[association] = arr if arr.any?
+      end
+      association_fields
+    end
+    association_fields
+  end
+
+  def build_filters
+    filterable_hash = {}
+    sanitized_filters.each do |filter, options|
+      if filter.select(options[:fields]).any?
+        a=klass_to_symbol(filter)
+        filterable_hash[a]={}
+        filterable_hash[a][:filters_by] = filter.name
+        filterable_hash[a][:collection] = filter.where(id: filter.pluck(:id))
+        filterable_hash[a][:fields] = options[:fields].map {|f| f if filter.instance_methods.include?(f) }
+        filterable_hash[a][:input_type] = options[:input_type]
+      end
+    end
+    filterable_hash
+  end
+
+  def data_pool
+    return apply_scope if sanitized_klass.key? :scope
+    return sanitized_klass[:universe] if sanitized_klass.key? :universe
+    operable_klass.send(:all)
+  end
+
+  def klass_keys(k)
+    k.new.attributes.keys.map { |k| k.to_sym }
+  end
+
+  def klass_to_symbol(k)
+    k.name.underscore.to_sym
+  end
+
+  def operable_klass
+    sanitized_klass[:klass]
+  end
+
+  def sanitize_klass
+    @sanitized_klass = {}
+    if @filter_feed[:klass]
+      @sanitized_klass[:klass] = @filter_feed[:klass]
+      @sanitized_klass[:universe] = @filter_feed[:universe] if @filter_feed.key? :universe
+      @sanitized_klass[:attributes] = []
+      @filter_feed[:non_associated_fields].collect { |naf| @sanitized_klass[:attributes] << naf if @filter_feed[:klass].new.respond_to?(naf) }
+      @sanitized_klass[:scope] = @filter_feed[:scope] if @filter_feed.key?(:scope) and  @filter_feed[:klass].respond_to?(@filter_feed[:scope])
+    end
+    @sanitized_klass
+  end
+
+  def sanitize_filters
+    @sanitized_filters = {}
+    @filter_collection.each do |filter|
+      klass = filter[:filterable]
+      attributes = filter[:fields]
+      safe_filters = []
+      safe_filters.push(*DEFAULT_FIELDS)
+      attributes.map { |f| safe_filters << f if klass.new.respond_to?(f) }
+      @sanitized_filters[klass] = {}
+      @sanitized_filters[klass][:fields] = safe_filters
+      # raise ACCEPTED_INPUT_TYPES.inspect
+      @sanitized_filters[klass][:input_type] = filter[:input_type] if ACCEPTED_INPUT_TYPES.include?(filter[:input_type])
+    end
+    @sanitized_filters
+  end
+
+  def sanitized_filters
+    @sanitized_filters
+  end
+
+  def sanitized_klass
+    @sanitized_klass
+  end
+
+  def set_meta_filters(args={})
+    @filter_feed=args[:feed]
+    @filter_collection=args[:collection]
+    sanitize_klass
+    sanitize_filters
+  end
+end

data/app/views/api/search/feed.json.jbuilder

@@ -0,0 +1,22 @@
+if feed && feed.any?
+  json.array!(feed) do |item|
+    json.id item.id
+    fields[:main].each do |field|
+      json.set! field, item.send(field)
+    end
+    fields.each do |association, attrs|
+      if association != :main
+        attrs[:fields].each do |field|
+          json.set! association, item.send(association).send(field) if item.send(association)
+        end
+      end
+    end
+    json.filters do 
+      fields.each do |association, attrs|
+        if association != :main
+          json.set! association, item.send(association).id if item.send(association)
+        end
+      end
+    end
+  end
+end

data/app/views/api/search/filters.json.jbuilder

@@ -0,0 +1,10 @@
+json.array!(filters) do |type, data|
+  json.title type.to_s.gsub(/_/, " ")
+  json.filter_by type
+  json.input_type data[:input_type]
+  json.filter_options(data[:collection]) do |instance|
+    data[:fields].each do |field|
+      json.set! field, instance.send(field)  
+    end 
+  end
+end 

data/config/routes.rb

@@ -0,0 +1,8 @@
+MorseSearchable::Engine.routes.draw do
+  concern :searchable do
+    collection do
+      get :feed
+      get :filters
+    end
+  end
+end

data/lib/morse_searchable.rb

@@ -0,0 +1,4 @@
+require "morse_searchable/engine"
+
+module MorseSearchable
+end

data/lib/morse_searchable/engine.rb

@@ -0,0 +1,11 @@
+module MorseSearchable
+  class Engine < ::Rails::Engine
+
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      # g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/morse_searchable/version.rb

@@ -0,0 +1,3 @@
+module MorseSearchable
+  VERSION = "0.0.3"
+end

data/lib/tasks/morse_searchable_tasks.rake

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

data/spec/controllers/searchable_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+class FakesController
+  include Searchable  
+
+  def set_meta_filters_here(args={})
+    set_meta_filters(args)
+  end
+end
+
+describe Searchable do
+
+  let(:sample) { new_sample }
+  let(:some_samples) { [new_sample] }
+  let(:no_samples) { [] }
+  let(:color) { new_color }
+  let(:some_colors) { [new_color] }
+  let(:no_colors) { [] }
+
+  let(:fakes_controller){FakesController.new}
+  let(:feed_non_specific){
+                      {feed: {klass: Sample, non_associated_fields: [:barcode]}, 
+                       collection: [
+                                     {filterable: ClothingType, fields: [:title, :poop]}, 
+                                     {filterable: Color, fields: [:title, :code] }
+                                   ]
+                      }
+                    }
+  let(:feed_universe){
+                      {feed: {klass: Sample, universe: some_samples, non_associated_fields: [:barcode]}, 
+                       collection: [
+                                     {filterable: ClothingType, fields: [:title, :poop]}, 
+                                     {filterable: Color, fields: [:title, :code] }
+                                   ]
+                      }
+                    }
+  let(:feed_vanilla){
+                      {feed: {klass: Sample, scope: :all, non_associated_fields: [:barcode]}, 
+                       collection: [
+                                     {filterable: ClothingType, fields: [:title, :poop]}, 
+                                     {filterable: Color, fields: [:title, :code] }
+                                   ]
+                      }
+                    }
+  let(:feed_vanilla_with_universe){
+                      {feed: {klass: Sample, scope: :all, non_associated_fields: [:barcode]}, 
+                       collection: [
+                                     {filterable: ClothingType, fields: [:title, :poop]}, 
+                                     {filterable: Color, universe:some_colors, fields: [:title, :code] }
+                                   ]
+                      }
+                    }
+  let(:feed_vanilla_with_universe_with_field_types){
+                    {feed: {klass: Sample, scope: :all, non_associated_fields: [:barcode]}, 
+                     collection: [
+                                   {filterable: ClothingType, fields: [:title, :poop], input_type: :select}, 
+                                   {filterable: Color, universe:some_colors, fields: [:title, :code], input_types: :select }
+                                 ]
+                    }
+                  }
+
+
+
+
+  before do
+    fakes_controller.set_meta_filters_here(feed_vanilla)
+  end
+
+  describe "apply_scope" do
+    it "should apply the scope" do
+      expect(Sample).to receive(:all).at_least(:once)
+        fakes_controller.send(:apply_scope)
+    end
+    it "should return an ARR" do
+
+      expect(fakes_controller.send(:apply_scope)).to be_a(Array)
+    end
+  end
+
+  describe "build_filters" do
+    it "does something" do
+      fakes_controller.send(:build_filters)
+    end
+  end
+
+  describe "data_pool" do
+    context "where a scope is given" do
+      it "should apply the scope" do
+        expect(fakes_controller).to receive(:apply_scope).at_least(:once)
+        fakes_controller.send(:data_pool)
+      end
+      it "should return an ARR" do
+        expect(fakes_controller.send(:data_pool)).to be_a(Array)
+      end
+    end
+
+    context "where a universe is given" do
+      before do
+        fakes_controller.set_meta_filters_here(feed_universe)
+      end
+      it "should return the universe" do
+        expect(fakes_controller.send(:data_pool)).to eq(some_samples) 
+      end
+    end
+
+    context "where neither scope nor universe is given" do
+      before do
+        fakes_controller.set_meta_filters_here(feed_non_specific)
+      end
+      it "should return the universe" do
+        expect(fakes_controller.send(:data_pool)).to eq(Sample.all) 
+      end
+    end
+  end
+
+  describe "operable_klass" do
+    it "should return the correct klass" do
+      expect(fakes_controller.send(:operable_klass)).to eq(Sample)
+    end
+  end
+  
+  describe "sanitize_filters" do
+    context "where a input type is passed" do
+      before do
+        fakes_controller.set_meta_filters_here(feed_vanilla_with_universe_with_field_types)
+      end
+      it "should include the input type in filter hash" do
+        expect(fakes_controller.send(:sanitize_filters)[ClothingType]).to include(:input_type => :select)
+      end
+    end
+  end
+
+  describe "sanitized_filters" do
+    subject{fakes_controller.send(:sanitized_filters)[ClothingType]}
+    it { is_expected.to include(:fields => [:id, :title]) }
+    context "removing junk attributes" do 
+      subject{fakes_controller.send(:sanitized_filters)[ClothingType][:fields]}
+      it { is_expected.to_not include(:poop) }
+      describe "it always includes id" do 
+        it { is_expected.to include(:id) }
+      end
+    end
+  end
+
+end
+

data/spec/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks