ceo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2eb7569c41149c06952565d2c06c67421b0e7d54
+  data.tar.gz: 7a4917ca99e37707b935ac219d4a3677f790efcb
+SHA512:
+  metadata.gz: 0c5b9119fef0659195d1481e226a5e1227a5edb3daa885d53c1dde7f6f7050ba21eed00f6464aaa76b917dda1dc7b52982b95bd5d1eaec2173bca1f3000b204c
+  data.tar.gz: 13c55c6ecbb45d24e33ca94ad28fc15ffce00638fe31ff53f0bc269cd0a819267d41b619997198a79abb19ac6941f5b14d81b49f76bf130b3fe397688c85d2cc

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Jesse Herrick and Littlelines, LLC.
+
+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.md

@@ -0,0 +1,10 @@
+CEO
+---
+
+> Your app's chief executive.
+[![Dependency Status](http://img.shields.io/gemnasium/littlelines/ceo.svg)](https://gemnasium.com/littlelines/ceo)
+[![Gem Version](http://img.shields.io/gem/v/ceo.svg)](https://rubygems.org/gems/ceo)
+[![License](http://img.shields.io/:license-mit-blue.svg)](http://littlelines.mit-license.org)
+[![Build Status](https://travis-ci.org/littlelines/ceo.svg?branch=master)](https://travis-ci.org/littlelines/ceo)
+[![Code Climate](https://codeclimate.com/github/littlelines/ceo/badges/gpa.svg)](https://codeclimate.com/github/littlelines/ceo)
+

data/Rakefile

@@ -0,0 +1,28 @@
+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    = 'Ceo'
+  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/admin/admin_controller.rb

@@ -0,0 +1,212 @@
+# Public: A base controller for admin pages.
+#
+# Routing:
+#   Routing can be dple `resource` route.
+class Admin::AdminController < ApplicationController
+  before_action :find_thing, only: [:show, :edit, :update, :destroy]
+
+  helper_method :thing_path
+  helper_method :things_path
+  helper_method :new_thing_path
+  helper_method :edit_thing_path
+
+  # GET /things
+  # Public: Indexes all things in the model.
+  #
+  # Uses pagination by default.
+  #
+  # Sets several variables and renders to a view.
+  def index(options = {})
+    options[:query] ||= []
+    @page = (params[:page] || 1).to_i
+    @route_name ||= @controller_name ||= controller_name
+
+    @iterator = CEO::Iterator.new(
+      thing,
+      query: options[:query],
+      page: @page,
+      per_page: options.fetch(:per_page, 20),
+      filters: {
+        only: options[:only],
+        except: options[:except]
+      }
+    )
+
+    @things = @iterator.all || []
+    @total_pages = @iterator.total_pages
+
+    @model_name ||= thing.to_s.underscore
+    @human_model = @model_name.humanize
+    @title = thing.to_s.titleize.pluralize
+    render 'admin/index'
+  end
+
+  # GET /:things/:id
+  def show(options = {})
+    @thing_model = thing
+    if options[:query]
+      query_out = {}
+      iterator = CEO::Iterator.new(thing)
+      options[:query].each do |q|
+        query_out.merge! iterator.query_eval(@thing, q)
+      end
+    end
+
+    filtered_keys = CEO::Iterator.filter(keys(@thing), options)
+    @thing_attrs = @thing.attributes.select do |k, _|
+      filtered_keys.include? k
+    end
+
+    @thing_attrs.transform_keys! { |k| CEO::Iterator.acronymize(k) }
+    @thing_attrs.merge! query_out if query_out
+
+    render 'admin/show'
+  end
+
+  # GET /:things/new
+  def new(options = { only: [], except: [:id, :created_at, :updated_at], required: [] })
+    @thing_model = thing
+    @thing = @thing_model.new
+    @attrs = CEO::Iterator.filter(@thing.attributes.keys, options)
+    @route_name ||= @controller_name ||= controller_name
+    @index_route = send(:"admin_#{@route_name}_path")
+
+    render 'admin/new'
+  end
+
+  # GET /:things/edit
+  #
+  # options - hash of options
+  #   only - filter attributes to edit by whitelist
+  #   except - filter attributes to edit by blacklist (has some preset defaults that you probably don't want)
+  def edit(options = { only: [], except: [:id, :created_at, :updated_at], required: [] })
+    @required_keys = options[:required]
+    @attrs = CEO::Iterator.filter(@thing.attributes.keys, options)
+    @model = @thing.model_name.name.constantize
+    @route_name ||= @controller_name ||= controller_name
+    @index_route = send(:"admin_#{@route_name}_path")
+
+    render 'admin/edit'
+  end
+
+  # POST /:things
+  def create
+    @thing = thing.new(thing_params)
+    @route_name ||= @controller_name ||= controller_name
+
+    if @thing.save
+      flash[:notice] = "#{thing} successfully created."
+      redirect_to things_path(@route_name), notice: "#{thing.to_s.titleize} successfully created."
+    else
+      render 'admin/new'
+    end
+  end
+
+  # PATCH/PUT /:things/:id
+  def update
+    @route_name ||= @controller_name ||= controller_name
+
+    if @thing.update(thing_params)
+      redirect_to things_path(@route_name), notice: "#{@controller_name.titleize} successfully updated."
+    else
+      render 'admin/edit'
+    end
+  end
+
+  # DELETE /:things/:id
+  def destroy
+    @thing.destroy
+
+    flash[:notice] = "#{thing} #{@thing.id} was successfully destroyed."
+    redirect_to action: :index
+  end
+
+  private
+
+  # Internal: Finds the ActiveRecord object of the current controller.
+  #
+  # Returns an ActiveRecord class.
+  def thing
+    controller_name.classify.constantize
+  end
+
+  # Private: Permits all model-defined parameters.
+  #
+  # Retuns a hash of parameters.
+  def thing_params
+    @params ||= thing.new.attributes.keys.map(&:to_sym)
+    params.require(thing.name.underscore.to_sym).permit(
+      @params,
+      :page
+    )
+  end
+
+  # Private: Finds an ActiveRecord object by id.
+  #
+  # Sets a variable `@thing`, which contains the object.
+  def find_thing
+    @thing = thing.find(params[:id])
+  end
+
+  # Private: Returns keys for a given model.
+  #
+  # Arguments:
+  #   - model: the model object to get the keys from
+  #
+  # Returns an array of keys.
+  def keys(model)
+    model.attributes.keys
+  end
+
+  # Private: Returns the path of the thing.
+  #
+  # object - An instance of a model.
+  #
+  # Returns the path of the thing.
+  def thing_path(model, object)
+    id = object['ID'] || object['id']
+    send(:"admin_#{model}_path", id: id)
+  end
+
+  # Private: Returns the index path of a model.
+  #
+  # object - An instance of a model.
+  #
+  # Returns the path of many things.
+  def things_path(object)
+    object ||= @route_name || controller_name
+    send(:"admin_#{object.pluralize}_path")
+  end
+
+  # Private
+  #
+  # model - The model name.
+  # object - An instance of a model.
+  #
+  # Returns the edit path of a model.
+  def edit_thing_path(model, object)
+    id = object['ID'] || object['id']
+    send(:"edit_admin_#{model}_path", id: id)
+  end
+
+  # Private
+  #
+  # model - The model name.
+  # object - An instance of a model.
+  #
+  # Returns the new path of a model.
+  def new_thing_path(model, object)
+    id = object['ID'] || object['id']
+    send(:"new_admin_#{model}_path", id: id)
+  end
+
+  # Private
+  #
+  # model - The model name.
+  # page - The page number.
+  #
+  # Returns the paginated path of an object.
+  def page_thing_path(model, page)
+    send(:"page_admin_#{model}_path", page: page)
+  end
+end

data/app/views/admin/index.html.erb

@@ -0,0 +1,71 @@
+<h1><%= @title %></h1>
+
+<table>
+  <thead>
+    <tr>
+      <% if @things.blank? %>
+        <%= "There are no #{@human_model.downcase.pluralize} in the database." %>
+      <% else %>
+        <% @things.first.each_key do |heading| %>
+          <th>
+            <%= heading %>
+          </th>
+        <% end %>
+      <% end %>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% @things.each do |thing| %>
+      <% thing.each do |heading, value| %>
+        <td label="<%= heading %>: ">
+          <%= value %>
+        </td>
+
+        <div class="actions">
+          <td><%= link_to("Edit #{@title}", edit_thing_path(@model_name, thing)) %></td>
+          <td><%= link_to("Show #{@title}", thing_path(@model_name, thing)) %></td>
+        </div>
+      <% end %>
+    <% end %>
+  </tbody>
+</table>
+
+<nav class="navigation" role="navigation">
+  <ul>
+    # First Page
+    <% unless @page == 1 %>
+      <li>
+        <%= link_to('1', thing_page_path(@model_name, @page - 1)) %>
+      </li>
+    <% end %>
+
+    # Previous Page
+    <% if @page > 1 %>
+      <li>
+        <%= link_to("#{page - 1}", thing_page_path(@model_name, @page - 1)) %>
+      </li>
+    <% end %>
+
+    # Current Page
+    <% unless @total_page == 1 %>
+      <li>
+        <a><%= @page %></a>
+      </li>
+    <% end %>
+
+    # Next Page
+    <% if @page < @total_pages %>
+      <li>
+        link_to("#{page + 1}", thing_page_path(@model_name, @page + 1))
+      </li>
+    <% end %>
+
+    # Last Page
+    <% unless @page == @total_pages %>
+      <li>
+        link_to("#{@total_pages}", thing_page_path(@model_name, @total_pages))
+      </li>
+    <% end %>
+  </ul>
+</nav>

data/lib/ceo/engine.rb

@@ -0,0 +1,4 @@
+module CEO
+  class Engine < Rails::Engine
+  end
+end

data/lib/ceo/iterator.rb

@@ -0,0 +1,154 @@
+# Public: Iterator for listing out things.
+module CEO
+  class Iterator
+    attr_reader :current_page, :total_pages
+
+    # model   - The model to perform queries on.
+    # options -
+    #   query - An array of nested queries.
+    #   filters - A hash of filters (only/except).
+    def initialize(model, options = {})
+      @model = model
+      @options = options
+      @queries = @options[:query] || []
+      @filters = @options[:filters] || {}
+    end
+
+    # Public: Iterates through all parts.
+    #
+    # Yields or returns an Enumerator.
+    def each
+      if block_yielded?
+        all.each do |thing|
+          yield(thing)
+        end
+      else
+        all.to_enum
+      end
+    end
+
+    # Public: Returns a hash of titleized attributes mapped to their values.
+    #
+    # Uses pagination.
+    #
+    # options -
+    #   current_page - currently paginated page
+    #   per_page     - # of things to list per page
+    #
+    # Returns a paginated hash of data.
+    def all
+      attribute_maps = [] # [{...}, {...}]
+      @pages = CEO::Paginator.new(
+        @model,
+        current_page: current_page,
+        per_page: @options.fetch(:per_page, 20)
+      )
+
+      self.total_pages = @pages.total_pages
+
+      @pages.each do |thing|
+        attr_object = {}
+
+        # TODO: Make all of this into a method.
+        # map first-level values to a hash
+        keys.each do |key|
+          attr_object[self.class.acronymize(key)] = thing[key.to_s]
+        end
+
+        # map nested values to a hash
+        @queries.each do |query|
+          attr_object.merge! query_eval(thing, query)
+        end
+        attribute_maps << attr_object
+      end
+      attribute_maps
+    end
+
+    # { 'Country Name' => 'South Korea' }
+    def query_eval(scope, query)
+      query_parts = query.split('.')
+      if query_parts.length > 2
+        title = self.class.acronymize(query_parts[-2..-1].join(' '))
+        resp = 'None' if scope.instance_eval(query_parts[0]).nil? || scope.instance_eval(query_parts[0..1].join('.')).nil?
+      elsif query_parts[-1] == 'name'
+        title = self.class.acronymize(query_parts.join(' '))
+        resp = 'None' if scope.instance_eval(query_parts[0]).nil?
+      else
+        title = self.class.acronymize query_parts[-1]
+        resp = 'None' if scope.instance_eval(query_parts[0]).nil?
+      end
+
+      resp = scope.instance_eval(query) unless resp == 'None'
+      { title => resp }
+    end
+
+    # Public: Filters an enum based on a hash of params.
+    #
+    # things  - An enum of things to filter.
+    # filters - A hash of filters (ALLOWED: [:only, :except]).
+    #
+    # Since 'only' and 'except' are mutually exclusive, 'only'
+    # will be prefered over 'except'.
+    #
+    # Returns a hash of filtered keys.
+    def self.filter(things, filters)
+      return self.only(things, filters[:only]) unless filters[:only].nil? || filters[:only].empty?
+      return self.except(things, filters[:except]) unless filters[:except].nil? || filters[:except].empty?
+
+      return things # if nothing to filter, just return the things
+    end
+
+    # Public: Blacklists keys based on an array.
+    #
+    # blacklist - An array of keys that are not allowed.
+    #
+    # Examples
+    #
+    #   blacklist = [:this, :that]
+    #   except([:this, :that, :here, :now], blacklist)
+    #   # => [:here, :now]
+    #
+    # Returns a filtered hash of keys.
+    def self.except(things, blacklist)
+      blacklist = blacklist.map(&:to_s)
+      things = things.map(&:to_s)
+      things.select { |thing| !blacklist.include? thing }
+    end
+
+    # Public: Whitelists keys based on an array.
+    #
+    # whitelist - An array of keys that are only allowed.
+    #
+    # Examples
+    #
+    #   whitelist = [:this, :that]
+    #   only([:this, :that, :here, :now], whitelist)
+    #   # => [:this, :that]
+    #
+    # Returns a filtered hash of keys.
+    def self.only(things, whitelist)
+      whitelist = whitelist.map(&:to_s)
+      things = things.map(&:to_s)
+      things.select { |thing| whitelist.include? thing }
+    end
+
+    def current_page
+      (@options[:current_page] || 1).to_i
+    end
+
+    # Public: Titleizes normal stuff, but upcases acronyms.
+    def self.acronymize(key)
+      parsed_key = key.to_s.titleize
+      parsed_key = parsed_key.gsub 'Id', 'ID'
+      parsed_key.gsub 'Iata Code', 'IATA'
+    end
+
+    private
+
+    attr_writer :total_pages
+
+    def keys
+      singleton_class.send(:filter, @model.new.attributes.keys, @filters)
+    end
+  end
+end

data/lib/ceo/paginator.rb

@@ -0,0 +1,118 @@
+module CEO
+  # Class to Paginate over active record scopes
+  #
+  # Ex:
+  #
+  #   Routes:
+  #
+  #     resources :users do
+  #       collection do
+  #         get 'page/:page', action: 'index', as: 'page', constraints: { page: /\d+/ }
+  #       end
+  #     en
+  #
+  #   Controller:
+  #
+  #     def index
+  #       @users = Paginator.new(
+  #         User.limit(100).order(name: :asc),
+  #         current_page: params.fetch(:page, 1).to_i,
+  #         per_page: 10
+  #       )
+  #     end
+  #
+  #
+  #   View with `paginate` helper:
+  #
+  #     .row
+  #       .large-12.columns
+  #         = paginate @users, :admin_users_path, intermediate_pages: 6
+  #
+  #
+  #   Simple View:
+  #
+  #   - if @order_paginator.has_previous?
+  #     = link_to 'previous page', orders_path(page: @order_paginator.previous_page)
+  #
+  #   - if @order_paginator.has_next?
+  #     = link_to 'next page', orders_path(page: @order_paginator.next_page)
+  #
+  class Paginator
+    include Enumerable
+
+    attr_accessor :scope, :current_page, :per_page
+
+    # Constructor
+    #
+    # scope - The ActiveRecord scope to page over
+    # current_page - The Number of the current page. >= 1
+    # per_page - The number of records per page
+    #
+    def initialize(scope, options)
+      @current_page = options.fetch :current_page
+      @per_page = options.fetch :per_page
+      @scope = scope
+    end
+
+    def has_previous?
+      current_page.to_i > 1
+    end
+
+    def has_next?
+      paged_scope.count == per_page
+    end
+
+    def multiple_pages?
+      total_pages.to_i > 1
+    end
+
+    def next_page
+      current_page.to_i + 1
+    end
+
+    def previous_page
+      if current_page.to_i - 1 > 0
+        current_page.to_i - 1
+      else
+        current_page.to_i
+      end
+    end
+
+    def each
+      paged_scope.each{|record| yield record }
+    end
+
+    def is_current_page?(page_number)
+      current_page.to_i == page_number.to_i
+    end
+
+    def intermediate_pages(max = 5)
+      floor = current_page - (max.to_f / 2).floor
+      ceil = current_page + (max.to_f / 2).ceil
+      floor = 1 if floor <= 0
+      ceil = total_pages if ceil > total_pages
+
+      floor.upto(ceil).collect{|page_num| page_num }
+    end
+
+    def total_results
+      @total_results ||= scope.count
+    end
+
+    def total_pages
+      @total_pages ||= (total_results.to_f / per_page).ceil
+    end
+
+    private
+
+    def paging_offset
+      return unless current_page
+
+      (current_page.to_i - 1).abs * per_page
+    end
+
+    def paged_scope
+      scope.offset(paging_offset).limit(per_page)
+    end
+  end
+end

data/lib/ceo/rails/routes.rb

@@ -0,0 +1,25 @@
+require 'action_dispatch/routing'
+require 'active_support/concern'
+
+module ActionDispatch::Routing
+  class Mapper
+    # Public: Generates default admin CRUD routes for resources.
+    #
+    # Returns a route.
+    def admin_for(*rsrcs)
+      rsrcs.map!(&:to_sym)
+
+      concern :pageable do
+        collection do
+          get '/page/:page', action: :index, as: 'page'
+        end
+      end
+
+      namespace :admin do
+        rsrcs.each do |r|
+          resources r, concerns: :pageable
+        end
+      end
+    end
+  end
+end

data/lib/ceo/version.rb

@@ -0,0 +1,3 @@
+module CEO
+  VERSION = '0.1.0'
+end

data/lib/ceo.rb

@@ -0,0 +1,8 @@
+require 'rails'
+require 'ceo/engine'
+require 'ceo/rails/routes'
+require 'ceo/paginator'
+require 'ceo/iterator'
+
+module CEO
+end

data/lib/tasks/ceo_tasks.rake

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