active_scaffold-sequel 0.3.0

data/lib/active_scaffold/data_structures/action_link.rb

@@ -0,0 +1,179 @@
+module ActiveScaffold::DataStructures
+  class ActionLink
+    # provides a quick way to set any property of the object from a hash
+    def initialize(action, options = {})
+      # set defaults
+      self.action = action
+      self.label = action
+      self.confirm = false
+      self.type = :collection
+      self.inline = true
+      self.method = :get
+      self.crud_type = :delete if [:destroy].include?(action.try(:to_sym))
+      self.crud_type = :create if [:create, :new].include?(action.try(:to_sym))
+      self.crud_type = :update if [:edit, :update].include?(action.try(:to_sym))
+      self.crud_type ||= :read
+      self.parameters = {}
+      self.html_options = {}
+      self.column = nil
+      self.image = nil
+      self.dynamic_parameters = nil
+
+      # apply quick properties
+      options.each_pair do |k, v|
+        setter = "#{k}="
+        self.send(setter, v) if self.respond_to? setter
+      end
+    end
+
+    # the action-path for this link. what page to request? this is required!
+    attr_accessor :action
+    
+    # the controller for this action link. if nil, the current controller should be assumed.
+    attr_writer :controller
+
+    def controller
+      @controller = @controller.call if @controller.is_a?(Proc)
+      @controller
+    end
+
+    def static_controller?
+      !@controller.is_a?(Proc)
+    end
+
+    # a hash of request parameters
+    attr_accessor :parameters
+
+    # a block for dynamic_parameters
+    attr_accessor :dynamic_parameters
+
+    # the RESTful method
+    attr_accessor :method
+
+    # what string to use to represent this action
+    attr_writer :label
+    def label
+      @label.is_a?(Symbol) ? as_(@label) : @label
+    end
+    
+    # image to use {:name => 'arrow.png', :size => '16x16'}
+    attr_accessor :image
+
+    # if the action requires confirmation
+    def confirm=(value)
+      @dhtml_confirm = nil if value
+      @confirm = value
+    end
+    def confirm(label = '')
+      @confirm.is_a?(String) ? @confirm : as_(@confirm, :label => label)
+    end
+    def confirm?
+      !!@confirm
+    end
+    
+    # if the action uses a DHTML based (i.e. 2-phase) confirmation
+    attr_accessor :dhtml_confirm
+    def dhtml_confirm=(value)
+      @confirm = nil if value
+      @dhtml_confirm = value
+    end
+    def dhtml_confirm?
+      !!@dhtml_confirm
+    end
+
+    # what method to call on the controller to see if this action_link should be visible
+    # note that this is only the UI part of the security. to prevent URL hax0rz, you also need security on requests (e.g. don't execute update method unless authorized).
+    attr_writer :security_method
+    def security_method
+      @security_method || "#{self.action}_authorized?"
+    end
+
+    def security_method_set?
+      !!@security_method
+    end
+    
+    attr_accessor :ignore_method
+    
+    # the crud type of the (eventual?) action. different than :method, because this crud action may not be imminent.
+    # this is used to determine record-level authorization (e.g. record.authorized_for?(:crud_type => link.crud_type).
+    # options are :create, :read, :update, and :delete
+    attr_accessor :crud_type
+
+    # an "inline" link is inserted into the existing page
+    # exclusive with popup? and page?
+    def inline=(val)
+      @inline = (val == true)
+      self.popup = self.page = false if @inline
+    end
+    def inline?; @inline end
+
+    # a "popup" link displays in a separate (browser?) window. this will eventually take arguments.
+    # exclusive with inline? and page?
+    def popup=(val)
+      @popup = (val == true)
+      if @popup
+        self.inline = self.page = false
+
+        # the :method parameter doesn't mix with the :popup parameter
+        # when/if we start using DHTML popups, we can bring :method back
+        self.method = nil
+      end
+    end
+    def popup?; @popup end
+
+    # a "page" link displays by reloading the current page
+    # exclusive with inline? and popup?
+    def page=(val)
+      @page = (val == true)
+      if @page
+        self.inline = self.popup = false
+
+        # when :method is defined, ActionView adds an onclick to use a form ...
+        # so it's best to just empty out :method whenever possible.
+        # we only ever need to know @method = :get for things that default to POST.
+        # the only things that default to POST are forms and ajax calls.
+        # when @page = true, we don't use ajax.
+        self.method = nil if method == :get
+      end
+    end
+    def page?; @page end
+
+    # where the result of this action should insert in the display.
+    # for :type => :collection, supported values are:
+    #   :top
+    #   :bottom
+    #   :replace (for updating the entire table)
+    #   false (no attempt at positioning)
+    # for :type => :member, supported values are:
+    #   :before
+    #   :replace
+    #   :after
+    #   false (no attempt at positioning)
+    attr_writer :position
+    def position
+      return @position unless @position.nil? or @position == true
+      return :replace if self.type == :member
+      return :top if self.type == :collection
+      raise "what should the default position be for #{self.type}?"
+    end
+
+    # what type of link this is. currently supported values are :collection and :member.
+    attr_accessor :type
+
+    # html options for the link
+    attr_accessor :html_options
+    
+    # nested action_links are referencing a column
+    attr_accessor :column
+    
+    # indicates that this a nested_link
+    def nested_link?
+      @column || (parameters && parameters[:named_scope])
+    end
+    
+    # Internal use: generated eid for this action_link
+    attr_accessor :eid
+    
+    
+  end
+end

data/lib/active_scaffold/data_structures/action_links.rb

@@ -0,0 +1,185 @@
+module ActiveScaffold::DataStructures
+  class ActionLinks
+    include Enumerable
+
+    def initialize
+      @set = []
+      @name = :root
+    end
+
+    # adds an ActionLink, creating one from the arguments if need be
+    def add(action, options = {})
+      link = if action.is_a?(ActiveScaffold::DataStructures::ActionLink) || action.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+        action
+      else
+        ActiveScaffold::DataStructures::ActionLink.new(action, options)
+      end
+      # NOTE: this duplicate check should be done by defining the comparison operator for an Action data structure
+      existing = find_duplicate(link)
+      unless existing
+        # That s for backwards compatibility if we are in root of action_links
+        # we have to move actionlink into members or collection subgroup
+        group = (name == :root ? subgroup(link.type, link.type) : self)
+        group.add_to_set(link)
+        link
+      else
+        existing
+      end
+    end
+    alias_method :<<, :add
+
+    def add_to_set(link)
+      @set << link
+    end
+
+    # adds a link to a specific group
+    # groups are represented as a string separated by a dot
+    # eg member.crud
+    def add_to_group(link, group = nil)
+      add_to = root
+      add_to = group.split('.').inject(root){|group, group_name| group.send(group_name)} if group
+      add_to << link unless link.nil?
+    end
+
+    # finds an ActionLink by matching the action
+    def [](val)
+      links = []
+      @set.each do |item|
+        if item.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+          collected = item[val]
+          links << collected unless collected.nil?
+        else
+          links << item if item.action == val.to_s
+        end
+      end
+      links.first
+    end
+
+    def find_duplicate(link)
+      links = []
+      @set.each do |item|
+        if item.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+          collected = item.find_duplicate(link)
+          links << collected unless collected.nil?
+        else
+          links << item if item.action == link.action and item.static_controller? && item.controller == link.controller and item.parameters == link.parameters
+        end
+      end
+      links.first
+    end
+
+    def delete(val)
+      self.each({:include_set => true}) do |link, set|
+        if link.action == val.to_s
+          set.delete_if {|item| item.is_a?(ActiveScaffold::DataStructures::ActionLink) && item.action == val.to_s}
+        end
+      end
+    end
+
+    def delete_group(name)
+      @set.each do |group|
+        if group.name == name
+          @set.delete_if {|item| item.is_a?(ActiveScaffold::DataStructures::ActionLinks) && item.name == name}
+        else
+          group.delete_group(name)
+        end if group.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+      end
+    end
+
+    # iterates over the links, possibly by type
+    def each(options = {}, &block)
+      @set.each {|item|
+        if item.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+          item.each(options, &block)
+        else
+          if options[:include_set]
+            yield item, @set
+          else
+            yield item
+          end
+        end
+      }
+    end
+    
+    def collect_by_type(type = nil)
+      links = []
+      subgroup(type).each(type) {|link| links << link}
+      links
+    end
+
+    def traverse(controller, options = {}, &block)
+      traverse_method = options.delete(:reverse).nil? ? :each : :reverse_each
+      options[:level] ||= -1
+      options[:level] += 1
+      first_action = true
+      @set.send(traverse_method) do |link|
+        if link.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+          unless link.empty?
+            yield(link, nil, {:node => :start_traversing, :first_action => first_action, :level => options[:level]})
+            link.traverse(controller,options, &block)
+            yield(link, nil, {:node => :finished_traversing, :first_action => first_action, :level => options[:level]})
+            first_action = false
+          end
+        elsif controller.nil? || !skip_action_link(controller, link, *(Array(options[:for])))
+          authorized = options[:for].nil? ? true : options[:for].authorized_for?(:crud_type => link.crud_type, :action => link.action)
+          yield(self, link, {:authorized => authorized, :first_action => first_action, :level => options[:level]})
+          first_action = false
+        end
+      end
+      options[:level] -= 1
+    end
+
+    def collect
+      @set
+    end
+
+    def empty?
+      @set.size == 0
+    end
+
+    def subgroup(name, label = nil)
+      group = self if name == self.name
+      group ||= @set.find do |item|
+        name == item.name if item.is_a?(ActiveScaffold::DataStructures::ActionLinks)
+      end
+
+      if group.nil?
+        group = ActiveScaffold::DataStructures::ActionLinks.new
+        group.label = label || name
+        group.name = name
+        add_to_set group
+      end
+      group
+    end
+
+    attr_writer :label
+    def label
+      as_(@label) if @label
+    end
+
+    def method_missing(name, *args, &block)
+      class_eval %{
+        def #{name}
+          @#{name} ||= subgroup('#{name}'.to_sym)
+          yield @#{name} if block_given?
+          @#{name}
+        end
+      }
+      send(name, &block)
+    end
+
+    attr_accessor :name
+
+    protected
+
+    def skip_action_link(controller, link, *args)
+      (!link.ignore_method.nil? && controller.respond_to?(link.ignore_method) && controller.send(link.ignore_method, *args)) || ((link.security_method_set? or controller.respond_to? link.security_method) and !controller.send(link.security_method, *args))
+    end
+
+    # called during clone or dup. makes the clone/dup deeper.
+    def initialize_copy(from)
+      @set = []
+      from.instance_variable_get('@set').each { |link| @set << link.clone }
+    end
+  end
+end

data/lib/active_scaffold/data_structures/actions.rb

@@ -0,0 +1,45 @@
+class ActiveScaffold::DataStructures::Actions
+  include Enumerable
+
+  def initialize(*args)
+    @set = []
+    self.add *args
+  end
+
+  def exclude(*args)
+    args.collect! { |a| a.to_sym } # symbolize the args
+    @set.reject! { |m| args.include? m } # reject all actions specified
+  end
+
+  def add(*args)
+    args.each { |arg| @set << arg.to_sym unless @set.include? arg.to_sym }
+  end
+  alias_method :<<, :add
+
+  def each
+    @set.each {|item| yield item}
+  end
+
+  def include?(val)
+    super val.to_sym
+  end
+
+  # swaps one element in the list with the other.
+  # accepts arguments in any order. it just figures out which one is in the list and which one is not.
+  def swap(one, two)
+    if include? one
+      exclude one
+      add two
+    else
+      exclude two
+      add one
+    end
+  end
+
+  protected
+
+  # called during clone or dup. makes the clone/dup deeper.
+  def initialize_copy(from)
+    @set = from.instance_variable_get('@set').clone
+  end
+end

data/lib/active_scaffold/data_structures/bridge.rb

@@ -0,0 +1,22 @@
+module ActiveScaffold::DataStructures
+  class Bridge
+    def self.install
+      raise(RunTimeError, "install not defined for bridge #{name}")
+    end
+      
+    # by convention and default, use the bridge name as the required constant for installation
+    def self.install?
+      Object.const_defined? name.demodulize
+    end
+      
+    def self.run
+      install if install?
+    end
+
+    def self.stylesheets
+    end
+
+    def self.javascripts
+    end
+  end
+end