admin_it 1.0.1

data/lib/admin_it/data/object.rb

@@ -0,0 +1,51 @@
+module AdminIt
+  module ObjectData
+    module Context
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def load_fields
+          all = entity_class.instance_methods(false) - Object.instance_methods
+          getters = all.select do |m|
+            m.to_s =~ /\w\z/ && entity_class.instance_method(m).arity == 0
+          end
+          setters = all.select do |m|
+            m.to_s[-1] == '=' && entity_class.instance_method(m).arity == 1
+          end
+          fields = getters.map do |m|
+            AdminIt::Field.create(
+              m,
+              entity_class,
+              readable: true,
+              writable: setters.include?("#{m}=".to_sym)
+            )
+          end
+          setters.reject! { |m| getters.include?(m.to_s[0..-2].to_sym) }
+          fields.concat(setters.map do |m|
+            name = m.to_s[0..-2].to_sym
+            AdminIt::Field.create(
+              name,
+              entity_class,
+              readable: false,
+              writable: true
+            )
+          end)
+        end
+      end
+    end
+
+    module Field
+      protected
+
+      def read_value(entity)
+        entity.send(name)
+      end
+
+      def write_value(entity, value)
+        entity.send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/admin_it/data.rb

@@ -0,0 +1,24 @@
+require File.join %w(admin_it data data_behavior)
+require File.join %w(admin_it data object)
+require File.join %w(admin_it data hash)
+require File.join %w(admin_it data active_record)
+
+module AdminIt
+  def self.register_data(entity_class, mod)
+    return if entity_class.nil?
+    @data_modules ||= []
+    @data_modules.unshift [entity_class, mod]
+  end
+
+  def self.data_module(entity_class)
+    return nil if entity_class.nil?
+    @data_modules ||= []
+    @data_modules.each do |mod|
+      return mod[1] if entity_class <= mod[0]
+    end
+  end
+
+  register_data Object, AdminIt::ObjectData
+  register_data Hash, AdminIt::HashData
+  register_data ActiveRecord::Base, AdminIt::ActiveRecordData
+end

data/lib/admin_it/definitions.rb

@@ -0,0 +1,89 @@
+#require 'delegate'
+
+module AdminIt
+  class ResourceDefinition # < SimpleDelegator
+    COLLECTIONS = %i(table tiles list)
+    SINGLE = %i(show new edit)
+    CONTEXTS = COLLECTIONS + SINGLE
+
+#    extend ExtendIt::ArrayOf
+
+#    array_of Context do
+#      scope(:all) { |_| true }
+#      find_by :name
+#    end
+
+#    dsl_array :context, ArrayOfContext, create_entity: :create_context
+
+    def initialize(resource)
+      @resource = resource
+      @resource.contexts.replace(CONTEXTS.map do |name|
+        Object.const_get("AdminIt::#{name.capitalize}Context")
+              .create_class(name, @resource)
+      end)
+    end
+
+    def exclude_context(*args)
+      args.flatten.each do |arg|
+        arg = Utils.assert_symbol_arg(arg) { next }
+        @resource.contexts.reject! { |c| c.context_name == arg }
+      end
+    end
+
+    def exclude_collection
+      @resource.contexts.reject! { |c| c.collection? }
+    end
+
+    def exclude_single
+      @resource.contexts.reject! { |c| c.single? }
+    end
+
+    def contexts(*names, &block)
+      unless names.empty?
+        @resource.contexts.replace(
+          names.flatten.uniq.map { |name| context(name) }
+        )
+      end
+      if block_given?
+        @resource.contexts.each { |context| context.instance_eval(&block) }
+      end
+    end
+
+    def context(name, context_class: nil, &block)
+      Utils.assert_symbol_arg!(name, 'name')
+      context = @resource[name]
+      if context.nil?
+        unless context_class <= Context
+          context_class =
+            Object.const_get("AdminIt::#{name.capitalize}Context")
+        end
+        context = context_class.create_class(name, @resource)
+        @resource.contexts << context
+      end
+      context.instance_eval(&block) if block_given?
+      context
+    end
+
+    def all(&block)
+      @resource.contexts.each { |c| c.instance_eval(&block) } if block_given?
+    end
+
+    def single(&block)
+      @resource.singles.each { |c| c.instance_eval(&block) } if block_given?
+    end
+
+    def collection(&block)
+      return unless block_given?
+      @resource.collections.each { |c| c.instance_eval(&block) }
+    end
+
+    def default_context(value)
+      return if @resource[value].nil?
+      @resource.instance_variable_set(:@default_context, value)
+    end
+
+    def icon(value = nil)
+      @resource.instance_variable_set(:@icon, value.to_s)
+    end
+  end
+end

data/lib/admin_it/engine.rb

@@ -0,0 +1,56 @@
+# require 'simple-navigation'
+# SimpleNavigation.config_file_paths << File.expand_path(File.join(%w(.. .. config)), __FILE__)
+
+module AdminIt
+  class Engine < Rails::Engine
+#    paths['app/controllers'] = File.join('lib', 'admin_it', 'controllers')
+
+    config.to_prepare do
+      Rails.application.config.i18n.load_path +=
+        Dir[Engine.root.join('lib', 'admin_it', 'locales', '*.yml')]
+
+      unless File.basename($0) == "rake" && ARGV.include?("db:migrate")
+        Dir[File.join(AdminIt.config.root, '**', '*.rb')].each do |file|
+          require file
+        end
+      end
+#      Assets.register(Rails.application.assets)
+
+#      AdminIt.init
+
+      Engine.routes.draw do
+        AdminIt.resources.each do |name, resource|
+          resources(resource.plural,
+                    controller: "admin_it/#{name}",
+                    except: [:index]) do
+            resource.collections.each do |context|
+              next unless context.collection?
+              get context.context_name, on: :collection
+            end
+            unless resource.collections.empty?
+              get('/', on: :collection, action: resource.default_context)
+            end
+          end
+        end
+        unless AdminIt.resources.empty?
+          name, resource = AdminIt.resources.first
+          get('/',
+              controller: "admin_it/#{name}",
+              action: resource.default_context)
+        end
+      end
+
+      #AdminIt.compile_menu
+
+      ActionController::Base.module_eval do
+        prepend_view_path 'lib/views'
+      end
+    end
+  end
+
+  def self.config
+    config = AdminIt::Config
+    yield config if block_given?
+    config
+  end
+end

data/lib/admin_it/env.rb

@@ -0,0 +1,37 @@
+module AdminIt
+  #
+  # Framework detection methods
+  #
+  module Env
+    # @private
+    def self.framework
+      return @framework unless @framework.nil?
+      gems = Gem.loaded_specs.keys
+      if gems.include?('rails')
+        @framework = :rails
+      elsif gems.include?('sinatra')
+        @framework = :sinatra
+      else
+        @framework = :unknown
+      end
+    end
+
+    # @private
+    def self.pundit?
+      Gem::Specification.find_by_name('pundit')
+      true
+    rescue Gem::LoadError
+      false
+    end
+
+    # @private
+    def self.rails?
+      framework == :rails
+    end
+
+    # @private
+    def self.sinatra?
+      framework == :sinatra
+    end
+  end
+end

data/lib/admin_it/errors.rb

@@ -0,0 +1,5 @@
+module AdminIt
+  class Error < StandardError; end
+  class FieldReadError < Error; end
+  class FieldWriteError < Error; end
+end

data/lib/admin_it/field/field.rb

@@ -0,0 +1,174 @@
+require File.join %w(extend_it class)
+require File.join %w(extend_it dsl)
+require File.join %w(extend_it callbacks)
+
+module AdminIt
+  #
+  # Describes any field of data
+  #
+  # @author [alexiss]
+  #
+  class Field
+    extend ExtendIt::Class
+    extend DataBehavior
+    include ExtendIt::Callbacks
+
+    TYPES = %i(unknown integer float string date relation enum)
+
+    define_callbacks :initialize#, :configure
+
+    class << self
+      extend ExtendIt::Dsl
+
+      # attr_reader :field_name, :entity_class
+
+      dsl_accessor :display_name do |value = nil|
+        value.nil? ? default_display_name : value.to_s
+      end
+
+      dsl_accessor :type, default: TYPES[0] do |value|
+        TYPES.include?(value) ? value : TYPES[0]
+      end
+
+      dsl_accessor :placeholder do |value = nil|
+        value.nil? ? display_name : value
+      end
+
+      dsl_boolean :readable, :writable, :visible, :sortable
+
+      dsl_block :read, :write, :render, :display
+
+      protected
+
+      def default_display_name
+        name.to_s
+      end
+    end
+
+    inherited_class_reader :field_name, :entity_class
+
+    def self.create(name, _entity_class,
+                    type: :unknown,
+                    readable: true,
+                    writable: true,
+                    visible: true,
+                    sortable: true
+                   )
+      base = self
+      Class.new(base) do
+        #run_callbacks :configure do
+        @field_name, @entity_class = name, _entity_class
+        import_data_module(base)
+        self.readable = readable
+        self.writable = writable
+        self.visible = visible
+        self.sortable = sortable
+        self.type = type
+        #end
+      end
+    end
+
+    def self.hide
+      @visible = false
+    end
+
+    def self.show
+      @visible = true
+    end
+
+    class_attr_reader :entity_class, :display_name, :type
+    attr_writer :visible, :readable, :writable
+
+    def initialize(readable: nil, writable: nil, visible: nil, sortable: nil)
+      run_callbacks :initialize do
+        @readable = readable.nil? ? self.class.readable? : readable == true
+        @writable = writable.nil? ? self.class.writable? : writable == true
+        @visible = visible.nil? ? self.class.visible? : visible == true
+        @sortable = sortable.nil? ? self.class.sortable? : sortable == true
+      end
+    end
+
+    def name
+      @name ||= self.class.field_name
+    end
+
+    def readable?
+      @readable == true
+    end
+
+    def writable?
+      @writable == true
+    end
+
+    def visible?
+      @visible == true
+    end
+
+    def sortable?
+      @sortable == true
+    end
+
+    def read(entity)
+      unless readable?
+        fail FieldReadError, "Attempt to read write-only field #{name}"
+      end
+      self.class.read.nil? ? read_value(entity) : self.class.read.call(entity)
+    end
+
+    def show(entity)
+      unless readable?
+        fail FieldReadError, "Attempt to read write-only field #{name}"
+      end
+      self.class.display.nil? ? show_value(entity) : self.class.display.call(entity)
+    end
+
+    def write(entity, value)
+      unless writable?
+        fail FieldWriteError, "Attempt to write read-only field #{name}"
+      end
+      if self.class.write.nil?
+        write_value(entity, value)
+      else
+        self.class.write.call(entity, value)
+      end
+      entity
+    end
+
+    def render(entity, instance: nil)
+      renderer = self.class.render
+      return if renderer.nil?
+      # method used as event emmiter, call block in instance or caller
+      # context if it present
+      if instance.nil?
+        self.class.render.call(entity)
+      else
+        instance.instance_exec(entity, &renderer)
+      end
+    end
+
+    def input(template, entity)
+      typed_method = "#{type}_input".to_sym
+      if respond_to?(typed_method)
+        send typed_method, template, entity
+      else
+        Helpers::Input.new(template, self, entity: entity)
+      end
+    end
+
+    protected
+
+    def read_value(entity)
+      raise NotImplementedError,
+            "Attempt to read field #{name} with unimplemented reader"
+    end
+
+    def show_value(entity)
+      read_value(entity)
+    end
+
+    def write_value(entity, value)
+      raise NotImplementedError,
+            "Attempt to write to field #{name} with unimplemented writer"
+    end
+  end
+end

data/lib/admin_it/field.rb

@@ -0,0 +1 @@
+require File.join %w(admin_it field field)

data/lib/admin_it/filters/entity_filter.rb

@@ -0,0 +1,4 @@
+module AdminIt
+  class EntityFilter < Filter
+  end
+end

data/lib/admin_it/filters/field_filter.rb

@@ -0,0 +1,31 @@
+module AdminIt
+  class FieldFilter < Filter
+    class << self
+      attr_reader :field
+
+      protected
+
+      def default_display_name
+        field.nil? ? superclass.default_display_name : field.display_name
+      end
+    end
+
+    class_attr_reader :field
+
+    def self.create(name, _resource, _field)
+      field_class = create_class(name, _resource)
+      field_class.class_eval do
+        _field = _field.to_sym if _field.is_a?(String)
+        @field =
+          if _field <= Field
+            _field
+          elsif _field.is_a?(Symbol)
+            @resource.fields.find { |fld| fld.field_name == _field }
+          else
+            nil
+          end
+      end
+      field_class
+    end
+  end
+end

data/lib/admin_it/filters/filter.rb

@@ -0,0 +1,150 @@
+require 'date'
+require 'json'
+require File.join %w(extend_it class)
+require File.join %w(extend_it dsl)
+require File.join %w(extend_it callbacks)
+require File.join %w(extend_it asserts)
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Symbolize
+
+module AdminIt
+  class Filter
+    extend ExtendIt::Class
+    extend DataBehavior
+    include ExtendIt::Callbacks
+    extend ExtendIt::Asserts
+
+    REGEXP = /\A(?<name>[a-zA-Z_][a-zA-Z0-9_]*)(?:\((?<params>[^)]*)\))?\z/
+
+    define_callbacks :save
+
+    class << self
+      extend ExtendIt::Dsl
+
+      attr_reader :filter_name, :resource
+
+      dsl_accessor :display_name do |value = nil|
+        value.nil? ? default_display_name : value.to_s
+      end
+
+      protected
+
+      def create_class(name, _resource)
+        assert_symbol(:name, binding: binding)
+        base = self
+        Class.new(base) do
+          @filter_name, @resource = name, _resource
+          @entity_class = @resource.entity_class
+          import_data_module(base)
+        end
+      end
+
+      def default_display_name
+        filter_name
+      end
+    end
+
+    def self.create(name, _resource)
+      create_class(name, _resource)
+    end
+
+    def self.load(str, filters)
+      m = REGEXP.match(str)
+      return nil if m.nil?
+      name = m[:name].to_sym
+      filter_class = filters.find { |f| f.filter_name == name }
+      return nil if filter_class.nil?
+      opts = {}
+      args = m[:params].nil? ? [] : m[:params].split(',').map do |param|
+        param.strip!
+        arr = param.split(':')
+        if arr.size > 1
+          opts[arr[0].strip.to_sym] = arr[1].strip
+          nil
+        else
+          arr[0]
+        end
+      end
+      args << opts unless opts.empty?
+      filter_class.new(*args.compact)
+    end
+
+    class_attr_reader :display_name
+
+    def name
+      @name ||= self.class.filter_name
+    end
+
+    def dump
+      args = []
+      opts = {}
+      result = ''
+      run_callbacks :save, arguments: { arguments: args, options: opts } do
+        result = "#{name}"
+        unless args.empty? && opts.empty?
+          args.concat(opts.map { |k, v| "#{k}:#{v}" })
+          result << "(#{args.join(',')})"
+        end
+      end
+      result
+    end
+
+    def change(str)
+    end
+
+    def apply(collection)
+      collection
+    end
+
+    protected
+
+    TRUE_VALUES = %i(true yes)
+    FALSE_VALUES = %i(false no)
+    NULL_VALUES = %i(nil null)
+    OCT_REGEXP = /\A0[0-7]+\z/
+    BIN_REGEXP = /\A0[bB][01]+\z/
+    HEX_REGEXP = /\A0[xX]\h+\z/
+    INT_REGEXP = /\A[+\-]?\d+\z/
+    FLOAT_REGEXP = /\A
+      [+\-]?
+      (?:\d*\.\d+(?:[eE][+\-]?\d+)?)|
+      (?:\d+(?:\.\d*)?[eE][+\-]?\d+)
+    \z/x
+    DATE = %q{[0-3]?[0-9][\/.\-][0-3]?[0-9][\/.\-](?:[0-9]{2})?[0-9]{2}}
+    TIME = %q{[0-2]?[0-9][.:\-][0-5]?[0-9]}
+    DATE_REGEXP = /\A#{DATE}\z/
+    TIME_REGEXP = /\A#{TIME}\z/
+    DATETIME_REGEXP = /\A#{DATE}(?:\s+|[\/.\-])#{TIME}\z/
+
+    def parse_argument(arg)
+      return arg unless arg.is_a?(String)
+      arg.strip!
+      sym = arg.downcase.to_sym
+      return nil if NULL_VALUES.include?(sym)
+      return true if TRUE_VALUES.include?(sym)
+      return false if FALSE_VALUES.include?(sym)
+      if (arg[0] == '\'' || arg[0] == '"') && arg[0] == arg[-1]
+        return arg[1..-2]
+      end
+      case arg
+      when OCT_REGEXP then arg.to_i(8)
+      when BIN_REGEXP then arg.to_i(2)
+      when HEX_REGEXP then arg.to_i(16)
+      when INT_REGEXP then arg.to_i(10)
+      when FLOAT_REGEXP then arg.to_f
+      when DATE_REGEXP then Date.parse(arg)
+      when TIME_REGEXP then Time.parse(arg)
+      when DATETIME_REGEXP then DateTime.parse(arg)
+      else JSON.parse(arg)
+      end
+    end
+
+    def create_argument(arg)
+      case arg
+      when String then "\"#{arg.gsub('"', '\\"')}\""
+      else arg.to_s
+      end
+    end
+  end
+end

data/lib/admin_it/filters/value_filter.rb

@@ -0,0 +1,52 @@
+module AdminIt
+  class ValueFilter < FieldFilter
+    attr_reader :values
+
+    def initialize(*values, **opts)
+      @values = values.map { |v| parse_argument(v) }.uniq
+    end
+
+    before_save do |arguments: [], options: {}|
+      arguments.concat(@values.map { |v| create_argument(v) })
+    end
+
+    def change(str)
+      return if str.nil? || !str.is_a?(String) || str.empty?
+      @values = [] unless /[+\-]/ =~ str
+      str.split(',').each do |param|
+        param.strip!
+        if param[0] == '-'
+          @values.delete_if { |v| v == parse_argument(param[1..-1]) }
+        else
+          param = param[1..-1] if param[0] == '+'
+          @values << parse_argument(param)
+        end
+      end
+      @values.uniq!
+    end
+
+    def all_values(collection = nil, &block)
+      collection ||= []
+      enum = Enumerator.new do |yielder|
+        values = collection.map { |e| self.class.field.read(e) }
+        values.uniq.each do |value|
+          yileder << {
+            value: value, count: values.count { |v| v == value }
+          }
+        end
+      end
+      block_given? ? enum.each(&block) : enum
+    end
+
+    def value(val)
+      create_argument(val)
+    end
+
+    def apply(collection)
+      return collection if @values.empty?
+      collection.select do |entity|
+        @values.include?(self.class.field.read(entity))
+      end
+    end
+  end
+end

data/lib/admin_it/filters.rb

@@ -0,0 +1,4 @@
+require File.join %w(admin_it filters filter)
+require File.join %w(admin_it filters field_filter)
+require File.join %w(admin_it filters entity_filter)
+require File.join %w(admin_it filters value_filter)