adva-core 0.0.3 → 0.0.4

data/app/views/layouts/default/_menu.rb

@@ -0,0 +1,19 @@
+class Layouts::Default::Menu < Adva::View::Menu
+  include do
+    def build
+      ul(:id => :menu) do
+        site.sections.each do |section|
+          item(section.name, url_for(section))
+        end
+        render_items
+      end
+    end
+
+    protected
+
+      def active?(url, options)
+        return false if url =~ %r(/admin/sites(/\d+)?$) && request.fullpath != url
+        super
+      end
+  end
+end

data/app/views/layouts/simple.rb

@@ -0,0 +1,16 @@
+class Layouts::Simple < Layouts::Base
+  include do
+    def body
+      div do
+        div :id => 'page' do
+          div :class => 'main' do
+            div :id => 'content' do
+              flash
+              content
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/pages/show.html.rb

@@ -0,0 +1,7 @@
+class Pages::Show < Minimal::Template
+  include do
+    def to_html
+      self << resource.article.body.html_safe
+    end
+  end
+end

data/config/initializers/simple_form.rb

@@ -0,0 +1,53 @@
+require 'simple_form'
+# Use this setup block to configure all options available in SimpleForm.
+SimpleForm.setup do |config|
+
+  # Components used by the form builder to generate a complete input. You can remove
+  # any of them, change the order, or even add your own components to the stack.
+  # config.components = [ :label_input, :hint, :error ]
+
+  # Default tag used on hints.
+  # config.hint_tag = :span
+
+  # Default tag used on errors.
+  # config.error_tag = :span
+
+  # Method used to tidy up errors.
+  # config.error_method = :first
+
+  # Default tag used for error notification helper.
+  # config.error_notification_tag = :p
+
+  # You can wrap all inputs in a pre-defined tag.
+  # config.wrapper_tag = :div
+
+  # CSS class to add to all wrapper tags.
+  # config.wrapper_class = :input
+
+  # CSS class to add to the wrapper if the field has errors.
+  # config.wrapper_error_class = :field_with_errors
+
+  # How the label text should be generated altogether with the required text.
+  config.label_text = lambda { |label, required| "#{label}#{required}" }
+
+  # Whether attributes are required by default (or not). Default is true.
+  # config.required_by_default = true
+
+  # Series of attemps to detect a default label method for collection.
+  # config.collection_label_methods = [ :to_label, :name, :title, :to_s ]
+
+  # Series of attemps to detect a default value method for collection.
+  # config.collection_value_methods = [ :id, :to_s ]
+
+  # Collection of methods to detect if a file type was given.
+  # config.file_methods = [ :file?, :public_filename ]
+
+  # Default priority for time_zone inputs.
+  # config.time_zone_priority = nil
+
+  # Default priority for country inputs.
+  # config.country_priority = nil
+
+  # Default size for text inputs.
+  # config.default_input_size = 50
+end

data/config/locales/en.yml

@@ -0,0 +1,129 @@
+en:
+  a_or_b: '%{a} or %{b}'
+
+  flash:
+    create:
+      notice: '%{resource_name} successfully created.'
+      alert:  '%{resource_name} could not be created.'
+    update:
+      notice: '%{resource_name} successfully updated.'
+      alert:  '%{resource_name} could not be updated.'
+    destroy:
+      notice: '%{resource_name} successfully deleted.'
+      alert:  '%{resource_name} could not be deleted.'
+    installation:
+      protected: "Installation for %{host} is already complete. Please log in with your admin account."
+
+  confirmations:
+    destroy: 'Do you really want to delete this %{model_name}?'
+
+  menu:
+    sections: Sections
+    page: Page
+    view: View
+    new: New
+    edit: Edit
+    edit_section: Settings
+    destroy: Delete
+    reorder: Reorder
+    confirm_destroy: "Do you really want to delete this %{model_name}?"
+
+  columns:
+    published: Published
+    author: Author
+
+  status:
+    published: Published
+
+  actions:
+    view: View
+    edit: Edit
+    destroy: Delete
+
+  section:
+    types:
+      page: Page
+    default_name: Home
+
+  installations:
+    new:
+      title: adva-cms installation
+      welcome: |
+        Welcome to the adva-cms less-than-one-minute installation process:
+        Just fill in a name for your site below and you're done.
+        Don't worry. You can always change everything later.
+      section_name: Section Name
+    show:
+      title: Success!
+      confirm: You have successfully created your site. Enjoy!
+      link_to_admin: "Manage your new site »"
+
+  admin:
+    sites:
+      index:
+        title: Sites
+      new:
+        title: Create a New Site
+        section_name: Section Name
+      edit:
+        title: Site Settings
+      show:
+        section:
+          new: New Section
+        site:
+          new: New Site
+    sections:
+      index:
+        title: Sections
+        published: Published
+      new:
+        title: Create a New Section
+    pages:
+      show:
+        title: Edit Page
+      new:
+        title: Create a New Section
+    tabs:
+      options: Options
+      assets: Assets
+
+  layouts:
+    default:
+      made_with: "Made with <a href=\"http://github.com/svenfuchs/adva-cms2\">adva cms 2</a>"
+    admin:
+      top:
+        sites: Sites
+        new_site: New Site
+        site: Overview
+        sections: Sections
+        new_section: New Section
+        settings: Settings
+        assets: Assets
+      header:
+        sign_in: "Sign in"
+        sign_out: "Sign out %{user}"
+        change_language: "Change language:"
+        website: "Website »"
+
+  simple_form:
+    "yes": 'Yes'
+    "no": 'No'
+    required:
+      text: required
+      mark: '*'
+      # You can uncomment the line below if you need to overwrite the whole required html.
+      # When using html, text and mark won't be used.
+      # html: '<abbr title="required">*</abbr>'
+    error_notification:
+      default_message: "Some errors were found, please take a look:"
+    # Labels and hints examples
+    # labels:
+    #   password: 'Password'
+    #   user:
+    #     new:
+    #       email: 'E-mail para efetuar o sign in.'
+    #     edit:
+    #       email: 'E-mail.'
+    # hints:
+    #   username: 'User name to sign in.'
+    #   password: 'No special characters, please.'

data/config/redirects.rb

@@ -0,0 +1,8 @@
+Adva::Registry.set :redirect, {
+  'installations#create'  => lambda { |c| c.installation_url(c.resource) },
+  'articles#show'         => lambda { |c| c.show_parent_url },
+
+  'admin/sites#update'    => lambda { |c| c.edit_url        },
+  'admin/pages#update'    => lambda { |c| c.show_url        },
+  'admin/pages#destroy'   => lambda { |c| c.index_url       }
+}

data/config/routes.rb

@@ -0,0 +1,21 @@
+require 'routing_filter'
+require 'adva/routing_filters/section_root'
+require 'adva/routing_filters/section_path'
+
+Rails.application.routes.draw do
+  filter :section_path, :section_root
+
+  namespace :admin do
+    resources :sites do
+      resources :sections, :only => [:index, :new, :create]
+      resources :pages
+    end
+  end
+
+  match 'pages/:id',              :to => 'pages#show',    :as => :page
+  match 'pages/:page_id/article', :to => 'articles#show', :as => :page_article
+
+  resources :installations, :only => [:new, :create, :show]
+
+  root :to => redirect('/installations/new') # should only match if no root section is present
+end

data/lib/adva-core.rb

@@ -0,0 +1 @@
+require 'adva/core'

data/lib/adva.rb

@@ -0,0 +1,40 @@
+require 'rails/engine'
+
+module Adva
+  autoload :Engine,     'adva/engine'
+  autoload :Generators, 'adva/generators'
+  autoload :Rack,       'adva/rack'
+  autoload :Registry,   'adva/registry'
+  autoload :Responder,  'adva/responder'
+  autoload :Tasks,      'adva/tasks/core'
+  autoload :Testing,    'adva/testing'
+  autoload :View,       'adva/view'
+
+  mattr_accessor :out
+  self.out = $stdout
+
+  class << self
+    def engines
+      @engines ||= constants.map do |name|
+        constant = const_get(name)
+        constant if constant != Adva::Core && constant.is_a?(Class) && constant < ::Rails::Engine
+      end.compact.sort { |lft, rgt| lft.name <=> rgt.name }.unshift(Adva::Core)
+    end
+
+    def engine(name)
+      name = "Adva::#{name.camelize}" unless name.to_s.starts_with?('Adva::')
+      engines.detect { |engine| engine.name == name }
+    end
+
+    def engine_names
+      @engine_names ||= engines.map { |constant| constant.name.split('::').last.underscore.to_sym }
+    end
+
+    def engine?(name)
+      engine_names.include?(name)
+    end
+    alias :installed? :engine?
+  end
+end
+
+

data/lib/adva/active_record/has_one_default.rb

@@ -0,0 +1,40 @@
+# Extends has_one associations to allow for a :default option.
+#
+# This will make the page.article association always build a default article
+# unless an article is already set or persisted.
+#
+#    class Page < ActiveRecord::Base
+#      has_one :article, :default => :build_default_article
+#
+#      def build_default_article
+#        build_article(:title => 'default title', :body => 'default body')
+#      end
+#    end
+#
+# Note that we also include a default scope that includes the associated record
+# to avoid n+1 queries.
+
+module ActiveRecord
+  module Associations
+    module HasOneDefault
+      def has_one(association_id, options = {})
+        default = options.delete(:default)
+        super
+        has_one_default(association_id, default) if default
+      end
+
+      def has_one_default(association_id, default)
+        default_scope includes(association_id) rescue nil # would raise during migrations. how to remove the rescue clause?
+        validates_presence_of association_id
+
+        define_method(:"#{association_id}_with_default") do
+          send(:"#{association_id}_without_default") || send(:"#{association_id}=", send(default))
+        end
+        alias_method_chain association_id, :default
+      end
+
+      ActiveRecord::Base.extend(self)
+    end
+  end
+end
+

data/lib/adva/active_record/has_options.rb

@@ -0,0 +1,55 @@
+module HasOptions
+  def has_option(*names)
+    unless respond_to?(:option_definitions)
+      include InstanceMethods
+      class_inheritable_accessor :option_definitions
+      self.option_definitions = {}
+      serialize :options
+    end
+
+    definition = names.extract_options!
+    names.map(&:to_sym).each do |name|
+      self.option_definitions[name] = definition
+
+      class_eval <<-rb, __FILE__, __LINE__
+        def #{name}
+          self.options ||= {}
+          options.key?(:#{name}) ? options[:#{name}] : option_default(:#{name})
+        end
+        # alias #{name}_before_type_cast #{name}
+
+        def #{name}=(value)
+          options_will_change!
+          self.options ||= {}
+          options[:#{name}] = option_type_cast(:#{name}, value)
+        end
+      rb
+    end
+  end
+
+  module InstanceMethods
+    OPTION_DEFAULTS = { :default => nil, :type => :string }
+
+    [:type, :default].each do |reader|
+      define_method(:"option_#{reader}") do |name|
+        self.class.option_definitions[name].key?(reader) ? self.class.option_definitions[name][reader] : OPTION_DEFAULTS[reader]
+      end
+    end
+
+    define_method :option_type_cast do |name, value|
+      return nil if value.nil?
+      case option_type(name)
+        when :string    then value.to_s
+        when :integer   then value.to_i rescue value ? 1 : 0
+        when :float     then value.to_f
+        when :datetime  then ActiveRecord::ConnectionAdapters::Column.string_to_time(value)
+        when :time      then ActiveRecord::ConnectionAdapters::Column.string_to_dummy_time(value)
+        when :date      then ActiveRecord::ConnectionAdapters::Column.string_to_date(value)
+        when :boolean   then ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
+        else value
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend(HasOptions)

data/lib/adva/cli.rb

@@ -0,0 +1,16 @@
+# TODO [cli] needs to use the local Gemfile if we're in an app
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../../Gemfile', __FILE__)
+
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default)
+
+Adva.engines.each { |engine| engine.new.load_tasks }
+
+if task = Thor::Util.find_by_namespace("adva:#{ARGV.first}")
+  ARGV.shift
+else
+  task = Thor::Util.find_by_namespace("adva:app")
+end
+
+task.start

data/lib/adva/controller.rb

@@ -0,0 +1,7 @@
+module Adva
+  module Controller
+    autoload :AbstractActions,  'adva/controller/abstract_actions'
+    autoload :References,       'adva/controller/references'
+    autoload :InternalRedirect, 'adva/controller/internal_redirect'
+  end
+end

data/lib/adva/controller/abstract_actions.rb

@@ -0,0 +1,92 @@
+require 'action_controller'
+
+# abstract_actions makes a base controller transparently use a concrete controller
+# for certain actions. E.g. with an sti base model like Section and concrete model
+# like Page if the route points to the SectionsController it still will use a
+# PagesController if the current resource is a Page.
+
+module Adva
+  module Controller
+    module AbstractActions
+      module ActMacro
+        def abstract_actions(options = {})
+          unless abstract_actions?
+            include InternalRedirect
+            include InstanceMethods
+
+            class_inheritable_accessor :abstract_action_options
+            self.abstract_action_options = options.reverse_merge(:except => [])
+
+            before_filter :internal_redirect
+          end
+        end
+
+        def abstract_actions?
+          included_modules.include?(InstanceMethods)
+        end
+      end
+
+      module InstanceMethods
+        def internal_redirect
+          if redirect_to_concretion?
+            internal_redirect_to_concretion
+          elsif redirect_to_abstraction?
+            internal_redirect_to_abstraction
+          end
+        end
+
+        protected
+
+          def redirect_to_abstraction?
+            concrete_controller? && !concrete_action?
+          end
+
+          def redirect_to_concretion?
+            !concrete_controller? && concrete_action?
+          end
+
+          def internal_redirect_to_abstraction
+            merge_params(abstract_instance_name, instance_name)
+            internal_redirect_to("#{abstract_controller_class.controller_path}##{params[:action]}")
+          end
+
+          def internal_redirect_to_concretion
+            merge_params(instance_name, abstract_instance_name)
+            internal_redirect_to("#{controller_namespace}/#{collection_name}##{params[:action]}")
+          end
+
+          def merge_params(to, from)
+            params[to] ||= {}
+            params[to].merge!(params.delete(from) || {})
+          end
+
+          def concrete_controller?
+            !self.instance_of?(abstract_controller_class)
+          end
+
+          def concrete_action?
+            !Array(abstract_action_options[:except]).include?(params[:action].to_sym)
+          end
+
+          def abstract_controller_class
+            @abstract_controller_class ||= begin
+              abstract = self.class
+              abstract = abstract.superclass until abstract.superclass.controller_name == 'base'
+              abstract
+            end
+          end
+
+          def abstract_instance_name
+            @abstract_instance_name ||= abstract_controller_class.controller_name.singularize
+          end
+
+          def controller_namespace
+            @controller_namespace ||= controller_path.split('/')[0..-2].join('/')
+          end
+      end
+
+      ActionController::Base.extend(ActMacro)
+    end
+  end
+end
+