toy-locomotive 0.2.0 → 0.3.2

data/lib/toy-locomotive/attributes/model.rb

@@ -1,23 +0,0 @@
-module ToyLocomotive::Attributes::Model
-  module ClassMethods
-
-    mattr_accessor :toy_attributes
-    self.toy_attributes = []
-
-    def attribute value
-      tattr = ToyLocomotive::Attributes::AttributeChain.new value, self
-      self.toy_attributes << tattr
-      tattr
-    end
-
-    def attributes
-      toy_attributes.select{|a| a.parent == self}
-    end
-
-    def use_toy_attributes?
-      true
-    end
-
-  end
-end
-ActiveRecord::Base.extend ToyLocomotive::Attributes::Model::ClassMethods

data/lib/toy-locomotive/attributes/observer.rb

@@ -1,43 +0,0 @@
-module ToyLocomotive
-  class AttributeObserver
-
-    attr_accessor :attribute
-
-    def initialize model
-      return unless model.respond_to?(:use_toy_attributes?) && model.use_toy_attributes?
-      @model = model
-      unless ActiveRecord::Base.connection.table_exists? @model.table_name
-        Class.new(ActiveRecord::Migration).create_table(@model.table_name.to_sym) do |t|
-          t.timestamps
-        end
-      end
-      @model.attributes.each do |attribute|
-        set_attribute(attribute)
-        @model.attr_accessible attribute.column
-        @model.attr_accessible :"#{attribute.column}_id" if attribute._as == :belongs_to
-      end
-      @model.reset_column_information
-    end
-
-    def set_attribute attribute
-      return if attribute.skip_table_column?
-      add_attribute attribute
-      update_attribute attribute
-    end
-
-    def add_attribute attribute
-      unless @model.column_names.include? attribute.to_table_column.to_s
-        Class.new(ActiveRecord::Migration).add_column @model.table_name.to_sym, attribute.to_table_column, attribute.to_table_type
-      end
-    end
-
-    def update_attribute attribute
-      column = @model.columns.select{|c| c.name == attribute.to_table_column.to_s}.first
-      if column && column.type != attribute.to_table_type
-        Class.new(ActiveRecord::Migration).change_column @model.table_name, attribute.to_table_column, attribute.to_table_type
-      end
-    end
-
-  end
-
-end

data/lib/toy-locomotive/auto_views/form.rb

@@ -1,54 +0,0 @@
-module ToyLocomotive::AutoViews
-  def auto_form_for args
-    if block_given?
-      form = ToyLocomotive::AutoViews::AutoForm.new
-      yield(form)
-    end
-    form_for args do |f|
-      arg = args.class == Array ? args.last : args
-      klass = arg.class
-      html = ''
-      klass.attributes.each do |attr|
-        next if attr.skip_table_column?
-        if attr.to_helper == :hidden_field
-          html += f.send :hidden_field, attr.to_table_column
-        else
-          html += "<fieldset class=\"#{attr.to_table_column}\">"
-          if attr.to_helper == :check_box
-            html += f.send attr.to_helper, attr.to_table_column
-            html += f.label attr.to_table_column
-          elsif attr.to_helper == :select
-            html += f.label attr.to_table_column
-            html += f.send attr.to_helper, attr.to_table_column, attr._options
-          else
-            html += f.label attr.to_table_column
-            html += f.send attr.to_helper, attr.to_table_column
-          end
-          html += "</fieldset>"
-        end
-      end
-      html += '<div class="actions">'
-      puts "+++++++++++++++++++"
-      puts form._actions if block_given?
-      puts "+++++++++++++++++++"
-      html += f.submit
-      html += link_to "Cancel", root_path
-      html += '</div>'
-      raw html
-    end.to_s
-  end
-end
-
-class ToyLocomotive::AutoViews::AutoForm
-  attr_accessor :_actions
-
-  def actions &blk
-    @_actions = blk
-  end
-
-  def _actions
-    @_actions.call.to_s
-  end
-end
-
-ActionView::Base.send :include, ToyLocomotive::AutoViews

data/lib/toy-locomotive/auto_views/show.rb

@@ -1,19 +0,0 @@
-module ToyLocomotive::AutoViews
-  def auto_show_for args
-    arg = args.class == Array ? args.last : args
-    klass = arg.class
-    html = '<div class="attributes-show">'
-    klass.attributes.each do |attr|
-      html += '<div class="attr-set">'
-        html += '<div class="attr-label">'+attr.column.to_s+'</div>'
-        html += '<div class="attr-content">'+arg.send(attr.column).to_s+'</div>'
-      html += '</div>'
-    end
-    html += '<div class="actions">'
-      html += link_to "Editar", {:action => :edit}, {:class => :edit}
-      html += link_to "Deletar", {:action => :destroy}, {:class => :destroy, :method => :delete, :confirm => "Tem certeza?"}
-    html += '</div>'
-    html += '</div>'
-    raw html
-  end
-end

data/lib/toy-locomotive/initializer.rb

@@ -1,20 +0,0 @@
-module ToyLocomotive
-  class Engine < Rails::Engine
-    initializer 'toy_locomotive.initialize', :after => :disable_dependency_loading do |app|
-      Dir["#{Rails.root}/app/models/*.rb"].each do |file|
-        require file
-        AttributeObserver.new file.split('/').last.split('.').first.classify.constantize
-      end
-      controllers = []
-      Dir["#{Rails.root}/app/controllers/*.rb"].each do |file|
-        require file
-        controllers << file.split('/').last.split('.').first.classify.constantize
-        controllers.last.append_filters!
-      end
-      Rails.application.class.routes.draw do
-        ToyLocomotive.routes.each {|route| match route[:path] => "#{route[:controller]}##{route[:action]}", as: route[:as], via: route[:method]}
-        controllers.each {|controller| controller.draws.each {|draw| send *draw}}
-      end
-    end
-  end
-end

data/lib/toy-locomotive/resources/controller.rb

@@ -1,101 +0,0 @@
-module ToyLocomotive::Resources::Controller
-
-  module ClassMethods
-    def extract_resources args
-      actions = {}
-      crud = [:index, :new, :create, :show, :edit, :update, :destroy]
-      if args.first == :all
-        actions[:crud] = crud
-        args.shift
-      end
-      hash = args.last || {}
-      actions[:crud] = hash[:only] if hash[:only]
-      actions[:crud] = crud - hash[:except] if hash[:except]
-      actions[:member] = hash[:member]
-      actions[:collection] = hash[:collection]
-      actions[:static] = hash[:static]
-      actions
-    end
-
-    def resources *args
-      res = extract_resources(args)
-      res[:crud].each{|action| send :"set_action_#{action}"} if res[:crud]
-      res[:member].each{|action| set_member_action(action)} if res[:member]
-      res[:collection].each{|action| set_collection_action(action)} if res[:collection]
-      res[:static].each{|action| set_static_action(action)} if res[:static]
-    end
-
-    def set_static_action action
-      get action.to_s do end
-    end
-
-    def set_member_action action
-      get action.to_s, on: 'member' do end
-    end
-
-    def set_collection_action action
-      get action.to_s, on: 'collection' do end
-    end
-
-    def set_action_new
-      get 'new' do
-        parent = extract_parent_vars.last
-        model = self.class.extract_model
-        instance_variable_set model.to_member_var, (parent ? parent.send(model.to_s.underscore.pluralize) : model).new
-      end
-    end
-
-    def set_action_index
-      get 'index' do
-        extract_parent_vars
-        extract_collection_var
-      end
-    end
-
-    def set_action_show
-      get 'show' do
-        extract_parent_vars
-        extract_member_var
-      end
-    end
-
-    def set_action_edit
-      get 'edit' do
-        extract_parent_vars
-        extract_member_var
-      end
-    end
-
-    def set_action_create
-      post 'create' do
-        parent = (vars = extract_parent_vars).last
-        model = self.class.extract_model
-        member = (parent ? parent.send(model.to_s.underscore.pluralize) : model).new(params[model.to_s.underscore.to_sym])
-        instance_variable_set model.to_member_var, member
-        vars = vars << member
-        return redirect_to vars, notice: 'Burrito was successfully created.' if member.save
-        render action: 'new'
-      end
-    end
-
-    def set_action_update
-      put 'update' do
-        vars = extract_parent_vars
-        vars = vars << (member = extract_member_var)
-        return redirect_to vars, notice: 'Burrito was successfully updated.' if member.update_attributes(params[member.class.to_s.underscore.to_sym])
-        render action: 'edit'
-      end
-    end
-
-    def set_action_destroy
-      delete 'destroy' do
-        vars = extract_parent_vars
-        extract_member_var.destroy
-        redirect_to action: :index, notice: 'Burrito was successfully deleted'
-      end
-    end
-
-  end
-
-end
-ActionController::Base.extend ToyLocomotive::Resources::Controller::ClassMethods

data/lib/toy-locomotive/router/block.rb

@@ -1,13 +0,0 @@
-module ToyLocomotive::Router::Block
-
-  def draw *args
-    (@_draws ||= []).push args
-  end
-
-  def draws
-    @_draws || []
-  end
-
-end
-
-ActionController::Base.extend ToyLocomotive::Router::Block

data/lib/toy-locomotive/router/controller.rb

@@ -1,134 +0,0 @@
-module ToyLocomotive::Router::Controller
-
-  module ClassMethods
-
-    %w(get put post delete).each {|via| eval "def #{via} path, opts={}, &blk; match_action \"#{via}\", path, opts, blk; end"}
-
-    def nested *args
-      @_nested = *args
-    end
-
-    def belongs_chain
-      (@_nested || []).map{|m| m.to_s.classify.constantize}
-    end
-
-    def route_chain
-      belongs_chain.map{|m| m.to_route}.join
-    end
-
-    def route_as
-      return "" unless extract_model
-      belongs_chain.map{|m| m.to_s.underscore }.join('_') << (belongs_chain.empty? ? extract_model.to_s.underscore : "_#{extract_model.to_s.underscore}")
-    end
-
-    def match_action method, path, opts, blk
-      action = extract_action path, opts, method
-      extract_filter action, path, opts, method
-      as = extract_as path, opts, method
-      path = extract_path path, opts
-      controller = extract_controller
-      add_route method, action, path, as, controller
-      define_method action, blk
-    end
-
-    def add_route method, action, path, as, controller
-      ToyLocomotive.routes ||= []
-      ToyLocomotive.routes << {method: method, action: action, path: path, controller: controller, as: as}
-      puts ({method: method, action: action, path: path, controller: controller, as: as}.inspect)
-    end
-
-    def add_member_filter action
-      @member_filters ||= []
-      @member_filters << action.to_sym
-    end
-
-    def add_collection_filter action
-      @collection_filters ||= []
-      @collection_filters << action.to_sym
-    end
-
-    def extract_path path, opts={}
-      return '/' if path == 'root'
-      return path if path[0] == '/'
-      return "/#{path.to_s.gsub('_','-').parameterize}" unless extract_model
-      return "#{route_chain}#{extract_model.to_route}/#{path.parameterize}" if opts[:on] == 'member' || path == 'edit'
-      return "#{route_chain}#{extract_model.to_route}" if ['show','update','destroy'].include?(path)
-      return "#{route_chain}/#{extract_model.to_s.underscore.pluralize}" if ['create', 'index'].include?(path)
-      "#{route_chain}/#{extract_model.to_s.underscore.pluralize}/#{path.parameterize}"
-    end
-
-    def extract_as path, opts={}, method='get'
-      return route_as.pluralize if path == 'index'
-      return route_as if path == 'show'
-      return nil if method != 'get'
-      action = extract_action path, opts
-      as = path[0] == '/' ? action : "#{action}"
-      as << "_#{route_as}" if extract_model
-      as
-    end
-
-    def extract_action path, opts={}, method='get'
-      (opts[:as] || (path == '/' ? 'root' : path)).parameterize.underscore
-    end
-
-    def extract_controller
-      to_s.gsub('Controller', '').downcase
-    end
-
-    def extract_model
-      extract_controller.singularize.camelize.constantize rescue nil
-    end
-
-    def extract_filter action, path, opts, method
-      return if path[0] == '/'
-      return if %w(index show new edit destroy update create).include? path
-      send :"add_#{opts[:on]}_filter", action if opts[:on]
-    end
-
-    def append_filters!
-      before_filter :extract_parent_vars, only: ((@member_filters || []) + (@collection_filters || []))
-      before_filter :extract_member_var, only: (@member_filters || [])
-      before_filter :extract_collection_var, only: (@collection_filters || [])
-    end
-
-  end
-
-  module InstanceMethods
-
-    def extract_parent_vars
-      chain = self.class.belongs_chain.reverse.clone
-      vars = []
-      if chain.any?
-        root = chain.pop
-        parent = root.find(params[root.to_params])
-        instance_variable_set root.to_member_var, parent
-        vars << parent
-        chain.each do |model|
-          parent = parent.send(model.to_s.underscore.pluralize).find(params[model.to_params])
-          instance_variable_set model.to_member_var, parent
-          vars << parent
-        end
-      end
-      vars
-    end
-
-    def extract_member_var
-      parent = self.class.belongs_chain.pop#reverse.pop
-      model = self.class.extract_model
-      parent = parent ? instance_variable_get(parent.to_member_var) : nil
-      instance_variable_set(model.to_member_var, (parent ? parent.send(model.to_s.underscore.pluralize) : model).find(params[model.to_params]))
-    end
-
-    def extract_collection_var
-      parent = self.class.belongs_chain.pop#reverse.pop
-      model = self.class.extract_model
-      parent = parent ? instance_variable_get(parent.to_member_var) : nil
-      instance_variable_set(model.to_collection_var, (parent ? parent.send(model.to_s.underscore.pluralize) : model.all))
-    end
-
-  end
-
-end
-
-ActionController::Base.extend ToyLocomotive::Router::Controller::ClassMethods
-ActionController::Base.send :include, ToyLocomotive::Router::Controller::InstanceMethods

data/lib/toy-locomotive/router/model.rb

@@ -1,40 +0,0 @@
-module ToyLocomotive::Router::Model
-
-  #def belongs_to_route
-  #  reflections = reflect_on_all_associations(:belongs_to)
-  #  reflections.any? ? reflections.first.name.to_s.camelize.constantize : nil
-  #end
-
-  #def belongs_chain chain=[]
-  #  parent_route = (chain.last || self).belongs_to_route
-  #  parent_route ? belongs_chain(chain << parent_route) : chain
-  #end
-
-  #def route_chain
-  #  belongs_chain.reverse.map{|m| m.to_route}.join
-  #end
-
-  def to_route
-    s = to_s.parameterize.downcase
-    "/#{s.pluralize}/:#{s}_id"
-  end
-
-  def to_member_var
-    "@#{to_s.underscore}"
-  end
-
-  def to_collection_var
-    to_member_var.pluralize
-  end
-
-  def to_params
-    :"#{to_s.underscore}_id"
-  end
-
-  #def to_as
-  #  belongs_chain.reverse!.map{|m| m.to_s.underscore }.join('_') << (belongs_chain.empty? ? to_s.underscore : "_#{to_s.underscore}")
-  #end
-
-end
-
-ActiveRecord::Base.extend ToyLocomotive::Router::Model