awestructx 0.4.0

data/lib/awestruct/page_loader.rb

@@ -0,0 +1,72 @@
+
+module Awestruct
+
+  class PageLoader
+
+    attr_reader :site
+    attr_reader :root_dir
+
+    def initialize(site, target=:pages)
+      @site   = site 
+      @target = target
+
+      @root_dir = site.config.dir
+      if ( @target == :layouts )
+        @root_dir = Pathname.new( File.join( root_dir, '_layouts/' ) )
+      end
+    end
+
+    def ignore?(path)
+      site.config.ignore.include?( path ) 
+    end
+
+    def load_all(prepare=:inline)
+      pages = []
+      root_dir.find do |path|
+        if ( path == root_dir )
+          next
+        end
+        basename = File.basename( path )
+        if ( basename == '.htaccess' )
+          #special case
+        elsif ( basename =~ /^[_.]/ )
+          Find.prune
+          next
+        end
+        relative_path = path.relative_path_from( root_dir ).to_s
+        if ignore?(relative_path)
+          Find.prune
+          next
+        end
+        unless path.directory?
+          page = load_page( path, prepare )
+          if ( page )
+            #inherit_front_matter( page )
+            site.send( @target ) << page
+            pages << page
+          end
+        end
+      end
+      if ( prepare == :post )
+        pages.each{|p| p.prepare!} 
+      end
+    end
+
+    def load_page(path,prepare=:inline)
+      pathname = case( path )
+        when Pathname:
+          pathname = path
+        else
+          pathname = Pathname.new( path )
+      end
+      chain = site.engine.pipeline.handler_chains[ path ]
+      return nil if chain.nil?
+      handler = chain.create(site, Pathname.new(path))
+      p = Page.new( site, handler )
+      p.prepare! if prepare == :inline
+      p
+    end
+
+  end
+
+end

data/lib/awestruct/pipeline.rb

@@ -0,0 +1,49 @@
+
+require 'awestruct/handler_chains'
+require 'awestruct/context_helper'
+
+module Awestruct
+
+  class Pipeline
+
+    attr_reader :handler_chains
+
+    def initialize()
+      @handler_chains = HandlerChains.new
+      @extensions     = []
+      @helpers        = []
+      @transformers   = []
+    end
+
+    def extension(e)
+      @extensions << e
+    end
+
+    def helper(h)
+      @helpers << h
+    end
+
+    def transformer(t)
+      @transformers << t
+    end
+
+    def execute(site)
+      execute_extensions(site)
+    end
+
+    def execute_extensions(site)
+      @extensions.each do |e|
+        e.execute(site)
+      end
+    end
+
+    def mixin_helpers(context)
+      context.extend( Awestruct::ContextHelper )
+      @helpers.each do |h|
+        context.extend(h)
+      end
+    end
+
+  end
+
+end

data/lib/awestruct/site.rb

@@ -0,0 +1,51 @@
+
+#require 'hashery/open_cascade'
+require 'awestruct/layouts'
+require 'awestruct/astruct'
+
+module Awestruct
+
+  class Site < Awestruct::AStruct
+
+    attr_reader :dir
+    attr_reader :output_dir
+    attr_reader :tmp_dir
+
+    attr_reader :pages
+    attr_reader :layouts
+
+    attr_reader :config
+    attr_reader :engine
+
+    def initialize(engine, config)
+      @engine = engine
+      @pages = []
+      @layouts = Layouts.new
+      @config = config
+      self.encoding = false
+    end
+
+    def inspect
+      "Site{:dir=>#{dir}}"
+    end
+
+    def dir
+      @config.dir
+    end
+
+    def output_dir
+      @config.output_dir
+    end
+
+    def tmp_dir
+      @config.tmp_dir
+    end
+
+    def load_page(path)
+      engine.load_path( self, path )
+    end
+
+
+  end
+
+end

data/lib/awestruct/util/default_inflections.rb

@@ -0,0 +1,45 @@
+      # Proc that is instance evaled to create the default inflections for both the
+      # model inflector and the inflector extension.
+      unless defined?( DEFAULT_INFLECTIONS_PROC )
+        DEFAULT_INFLECTIONS_PROC = proc do
+          plural(/$/, 's')
+          plural(/s$/i, 's')
+          plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')
+          plural(/(buffal|tomat)o$/i, '\1oes')
+          plural(/([ti])um$/i, '\1a')
+          plural(/sis$/i, 'ses')
+          plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+          plural(/(hive)$/i, '\1s')
+          plural(/([^aeiouy]|qu)y$/i, '\1ies')
+          plural(/(x|ch|ss|sh)$/i, '\1es')
+          plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+          plural(/([m|l])ouse$/i, '\1ice')
+      
+          singular(/s$/i, '')
+          singular(/([ti])a$/i, '\1um')
+          singular(/(analy|ba|cri|diagno|parenthe|progno|synop|the)ses$/i, '\1sis')
+          singular(/([^f])ves$/i, '\1fe')
+          singular(/([h|t]ive)s$/i, '\1')
+          singular(/([lr])ves$/i, '\1f')
+          singular(/([^aeiouy]|qu)ies$/i, '\1y')
+          singular(/(m)ovies$/i, '\1ovie')
+          singular(/(x|ch|ss|sh)es$/i, '\1')
+          singular(/([m|l])ice$/i, '\1ouse')
+          singular(/buses$/i, 'bus')
+          singular(/oes$/i, 'o')
+          singular(/shoes$/i, 'shoe')
+          singular(/(alias|(?:stat|octop|vir|b)us)es$/i, '\1')
+          singular(/(vert|ind)ices$/i, '\1ex')
+          singular(/matrices$/i, 'matrix')
+      
+          irregular('person', 'people')
+          irregular('man', 'men')
+          irregular('child', 'children')
+          irregular('sex', 'sexes')
+          irregular('move', 'moves')
+          irregular('quiz', 'quizzes')
+          irregular('testis', 'testes')
+      
+          uncountable(%w(equipment information rice money species series fish sheep news))
+        end
+      end

data/lib/awestruct/util/inflector.rb

@@ -0,0 +1,242 @@
+# The inflector extension adds inflection instance methods to String, which allows the easy transformation of
+# words from singular to plural, class names to table names, modularized class
+# names to ones without, and class names to foreign keys.  It exists for 
+# backwards compatibility to legacy Sequel code.
+
+class String
+  # This module acts as a singleton returned/yielded by String.inflections,
+  # which is used to override or specify additional inflection rules. Examples:
+  #
+  #   String.inflections do |inflect|
+  #     inflect.plural /^(ox)$/i, '\1\2en'
+  #     inflect.singular /^(ox)en/i, '\1'
+  #
+  #     inflect.irregular 'octopus', 'octopi'
+  #
+  #     inflect.uncountable "equipment"
+  #   end
+  #
+  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
+  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
+  # already have been loaded.
+  module Inflections
+    @plurals, @singulars, @uncountables = [], [], []
+
+    class << self
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
+    end
+
+    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
+    # the options are: :plurals, :singulars, :uncountables
+    #
+    # Examples:
+    #   clear :all
+    #   clear :plurals
+    def self.clear(scope = :all)
+      case scope
+      when :all
+        @plurals, @singulars, @uncountables = [], [], []
+      else
+        instance_variable_set("@#{scope}", [])
+      end
+    end
+
+    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
+    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
+    #
+    # Examples:
+    #   irregular 'octopus', 'octopi'
+    #   irregular 'person', 'people'
+    def self.irregular(singular, plural)
+      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
+      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
+    end
+
+    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   plural(/(x|ch|ss|sh)$/i, '\1es')
+    def self.plural(rule, replacement)
+      @plurals.insert(0, [rule, replacement])
+    end
+
+    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
+    # The replacement should always be a string that may include references to the matched data from the rule.
+    #
+    # Example:
+    #   singular(/([^aeiouy]|qu)ies$/i, '\1y') 
+    def self.singular(rule, replacement)
+      @singulars.insert(0, [rule, replacement])
+    end
+
+    # Add uncountable words that shouldn't be attempted inflected.
+    #
+    # Examples:
+    #   uncountable "money"
+    #   uncountable "money", "information"
+    #   uncountable %w( money information rice )
+    def self.uncountable(*words)
+      (@uncountables << words).flatten!
+    end
+
+    load( File.join( File.dirname(__FILE__), 'default_inflections.rb' ) )
+    instance_eval(&DEFAULT_INFLECTIONS_PROC)
+  end
+
+  # Yield the Inflections module if a block is given, and return
+  # the Inflections module.
+  def self.inflections
+    yield Inflections if block_given?
+    Inflections
+  end
+
+  # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
+  # is set to :lower then camelize produces lowerCamelCase.
+  #
+  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+  #
+  # Examples
+  #   "active_record".camelize #=> "ActiveRecord"
+  #   "active_record".camelize(:lower) #=> "activeRecord"
+  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
+  def camelize(first_letter_in_uppercase = :upper)
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
+  end
+  alias_method :camelcase, :camelize
+
+  # Singularizes and camelizes the string.  Also strips out all characters preceding
+  # and including a period (".").
+  #
+  # Examples
+  #   "egg_and_hams".classify #=> "EggAndHam"
+  #   "post".classify #=> "Post"
+  #   "schema.post".classify #=> "Post"
+  def classify
+    sub(/.*\./, '').singularize.camelize
+  end
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  def constantize
+    raise(NameError, "#{inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(self)
+    Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  # Example
+  #   "puni_puni".dasherize #=> "puni-puni"
+  def dasherize
+    gsub(/_/, '-')
+  end
+
+  # Removes the module part from the expression in the string
+  #
+  # Examples
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    gsub(/^.*::/, '')
+  end
+
+  # Creates a foreign key name from a class name.
+  # +use_underscore+ sets whether the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key #=> "message_id"
+  #   "Message".foreign_key(false) #=> "messageid"
+  #   "Admin::Post".foreign_key #=> "post_id"
+  def foreign_key(use_underscore = true)
+    "#{demodulize.underscore}#{'_' if use_underscore}id"
+  end
+
+  # Capitalizes the first word and turns underscores into spaces and strips _id.
+  # Like titleize, this is meant for creating pretty output.
+  #
+  # Examples
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize
+    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  # Returns the plural form of the word in the string.
+  #
+  # Examples
+  #   "post".pluralize #=> "posts"
+  #   "octopus".pluralize #=> "octopi"
+  #   "sheep".pluralize #=> "sheep"
+  #   "words".pluralize #=> "words"
+  #   "the blue mailman".pluralize #=> "the blue mailmen"
+  #   "CamelOctopus".pluralize #=> "CamelOctopi"
+  def pluralize
+    result = dup
+    Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # The reverse of pluralize, returns the singular form of a word in a string.
+  #
+  # Examples
+  #   "posts".singularize #=> "post"
+  #   "octopi".singularize #=> "octopus"
+  #   "sheep".singluarize #=> "sheep"
+  #   "word".singluarize #=> "word"
+  #   "the blue mailmen".singularize #=> "the blue mailman"
+  #   "CamelOctopi".singularize #=> "CamelOctopus"
+  def singularize
+    result = dup
+    Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(downcase)
+    result
+  end
+
+  # Underscores and pluralizes the string.
+  #
+  # Examples
+  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+  #   "egg_and_ham".tableize #=> "egg_and_hams"
+  #   "fancyCategory".tableize #=> "fancy_categories"
+  def tableize
+    underscore.pluralize
+  end
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. Titleize is meant for creating pretty output.
+  #
+  # titleize is also aliased as as titlecase
+  #
+  # Examples
+  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
+  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+  def titleize
+    underscore.humanize.gsub(/\b([a-z])/){|x| x[-1..-1].upcase}
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of camelize. Makes an underscored form from the expression in the string.
+  # Also changes '::' to '/' to convert namespaces to paths.
+  #
+  # Examples
+  #   "ActiveRecord".underscore #=> "active_record"
+  #   "ActiveRecord::Errors".underscore #=> active_record/errors
+  def underscore
+    gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end
+end