binder_core 0.1.0

data/lib/binder_core/file_ref.rb

@@ -0,0 +1,38 @@
+# hook to help the api appear cleaner when dealing with file objects
+module BinderCore
+  class FileRef
+    attr_accessor :path 
+    def initialize path = nil
+      @path = path
+    end
+    
+    def name
+      File.basename( @path, File.extname(@path) )
+    end
+    
+    def full_name
+      File.basename( @path )
+    end
+    
+    def ext
+      File.extname(@path)
+    end
+    
+    def dir?
+      File.directory?(@path)
+    end
+    
+    def files 
+      # return an array of File objects for each file in this directory
+      # if it is not at Directory return an empty array
+      fls = []   
+      if self.dir? 
+        Dir.foreach(@path) do |fname|
+          next if fname == '.' or fname == '..'
+          fls << fname
+        end
+      end
+      fls
+    end
+  end
+end

data/lib/binder_core/folder_context.rb

@@ -0,0 +1,55 @@
+module BinderCore
+  class FolderContext
+    attr_accessor :parsers, :rules, :file, :route, :data, :assets, :console, :params
+    
+    def initialize
+      @rules    = []
+      @parsers  = []
+      @route    = []
+      @assets   = []
+      @params   = {}
+    end
+    
+    def raw
+      {:data => data,:assets => assets}
+    end
+    
+    def parse_files
+      file.files.each do |fname|
+        # allow the console.continue? flag to halt the compile process
+        break unless console.continue?
+        
+        file_config = lambda do |config|
+          config.set_route    @route.dup
+          config.set_path     File.join(file.path, fname)
+          config.add_params   @params.dup
+          config.set_console  console
+          config.set_rules    @rules.dup
+          config.set_parsers  @parsers.dup
+          config.set_assets   @assets
+          config.verify_context
+        end
+        
+        parsed_file = Scanner.scan file_config
+        if parsed_file.data then add_data_from( parsed_file ) end
+      end
+      @data = expand_single_keys @data unless @data.nil?
+      raw
+    end
+    
+    private
+    def add_data_from( file_context )
+      @data ||= {}
+      key =  file_context.name
+      if @data.has_key? key then @data[key] << file_context.data
+      else @data[key] = [file_context.data]
+      end
+    end
+    def expand_single_keys( hash )
+      hash.keys.each do |key| 
+        hash[key] = hash[key][0] if hash[key].length == 1 
+      end
+      hash
+    end
+  end
+end

data/lib/binder_core/parser.rb

@@ -0,0 +1,82 @@
+module BinderCore
+  # This is the base class for all parsers.
+  # When it is instanciated it is assigned one FileContext, which may be a file or a folder.
+  # Subclasses must define a parse method which is called when the time is right.
+  # 
+  # If the parse method doesn't actively add data, create a new asset and/or descend into a folder 
+  # then nothing gets added to the binder data and the scanner essentaily skips this file/folder.
+  # 
+  # Hence the NullParser implmentation:
+  # 
+  #   class NullParser < BinderCore::Parser
+  #     def parse
+  #     end
+  #   end
+  # 
+  class Parser
+    def initialize(file_context)
+      @context = file_context
+    end
+    
+    # Access FileRef object associated with this Parser
+    def file
+      @context.file
+    end
+    
+    # if you dont supply a second argument to the 'add' method
+    # this is the key that will be used when adding a data value to the parent hash
+    def key=(val)
+      @context.name = val
+    end
+    
+    def key
+      @context.name
+    end
+    
+    # adds a data value object to the parent hash
+    # you can specify the key if you supply a second parameter, otherwise 'self.key' is used
+    def add(data, key = "")
+      if !key.empty? then @context.name = key end
+      @context.data = data
+    end
+    
+    # This creates a new asset object and adds it to the binder asset bucket.
+    # You have the option of supplying a path to a file, otherwise it creates an asset using
+    # the current file path
+    def new_asset(path = nil)
+      path ||= @context.file.path
+      @context.register_asset BinderCore::Asset.new( path )
+    end
+    
+    # The console is used for debugging, it allows you to log messages and warnings. 
+    # You can also trigger an internal error halting the parsing process. 
+    # Check out BinderCore::Console
+    def console
+      @context.console
+    end
+    
+    # Access to arbitary user params inherited from the parent context.
+    # Any changes you make to this will be similarly inherited by direct children using a shallow duplicate.
+    def params
+      @context.params
+    end
+    
+    # Instructs the compiler to decend into this folder and scan.
+    # You can override the path in the config block if you want to direct the compiler to a folder elsewhere. 
+    # It will happily scan a different folder without disrupting the rest of the process.
+    # 
+    # The config block works the same as the one used when you defined the binder. This means that you can
+    # add new parser definitions which will only be applied to children of the folder... powerful stuff!
+    # 
+    # This method returns the data gleemed from that scanning process, you need to
+    # add it to make it part of the binder data, it will not do so automatically!
+    # 
+    # On the other hand, assets ARE automatically added to the binder asset bucket when created.
+    # 
+    def descend(&config)
+      config ||= lambda { |c|  }
+      raw = @context.descend &config
+      raw[:data]
+    end
+  end
+end

data/lib/binder_core/parsers/asset_parser.rb

@@ -0,0 +1,7 @@
+module BinderCore
+  class AssetParser < BinderCore::Parser
+    def parse
+      add new_asset
+    end
+  end
+end

data/lib/binder_core/parsers/folder_parser.rb

@@ -0,0 +1,7 @@
+module BinderCore
+  class FolderParser < BinderCore::Parser
+    def parse
+      add descend
+    end
+  end
+end

data/lib/binder_core/parsers/null_parser.rb

@@ -0,0 +1,6 @@
+module BinderCore
+  class NullParser < BinderCore::Parser
+    def parse
+    end
+  end
+end

data/lib/binder_core/parsers/text_parser.rb

@@ -0,0 +1,11 @@
+module BinderCore
+  class TextParser < BinderCore::Parser
+    def parse
+      add read_utf
+    end
+    
+    def read_utf
+      File.open( self.file.path, 'r:UTF-8') { |f| f.read } 
+    end
+  end
+end

data/lib/binder_core/registry.rb

@@ -0,0 +1,45 @@
+module BinderCore
+  class Registry
+    include Enumerable
+
+    def initialize(name)
+      @name  = name
+      @items = {}
+    end
+
+    def add(item)
+      add_as(item.name, item)
+      item
+    end
+
+    def find(name)
+      @items[name.to_sym] or raise ArgumentError.new("#{@name} not registered: #{name.to_s}")
+    end
+
+    def each(&block)
+      @items.values.uniq.each(&block)
+    end
+
+    def [](name)
+      find(name)
+    end
+
+    def registered?(name)
+      @items.key?(name.to_sym)
+    end
+
+    def clear
+      @items.clear
+    end
+
+    private
+
+    def add_as(name, item)
+      if registered?(name)
+        raise DuplicateDefinitionError, "#{@name} already registered: #{name}"
+      else
+        @items[name.to_sym] = item
+      end
+    end
+  end
+end

data/lib/binder_core/scanner.rb

@@ -0,0 +1,36 @@
+module BinderCore
+  class Scanner
+    # Parse a file obtaining a parser from the configured definitions.
+    # Returns a parsed file context
+    def self.scan(config)
+      # configure the context
+      context = FileContext.new
+      config.call Config.new context
+      context.console.stack.add_file context.route, context
+      # parse the file
+      file_parser = get_parser_for context
+      context.console.stack.add_parser context.route, file_parser
+      file_parser.parse
+      # return parsed context
+      context
+    end
+    
+    # Parse all files in a directory
+    def self.descend(config)
+      context = FolderContext.new
+      config.call Config.new context
+      context.console.stack.add_folder context.route, context
+      context.parse_files
+    end
+    
+    private 
+    # Runs the configured file context against all the rule and parser
+    # definitions test method and returns an instance of the first one that matches
+    def self.get_parser_for file_context
+      [*file_context.rules,*file_context.parsers].each do |defn|
+        parser = defn.test( file_context )
+        return parser.new( file_context ) if parser.kind_of?(Class)
+      end
+    end
+  end
+end

data/lib/binder_core/settings.rb

@@ -0,0 +1,23 @@
+module BinderCore
+  class Settings
+    
+    def self.configure(&block)
+      instance_eval &block
+    end
+    
+    def self.config
+      @config ||= Config.new
+    end
+    
+    def self.propegate
+      config.clone
+    end
+    
+    class Config
+      attr_accessor :base_asset_url, :content_folder, :folder_size_limit_mb, :base_asset_folder
+      def prop_list
+        (self.public_methods - [*Object.public_methods,:prop_list]).sort
+      end
+    end
+  end
+end

data/lib/binder_core/version.rb

@@ -0,0 +1,3 @@
+module BinderCore
+  VERSION = "0.1.0"
+end

data/lib/binder_core.rb

@@ -0,0 +1,44 @@
+require "binder_core/version"
+require "binder_core/binder"
+require "binder_core/compiler"
+require "binder_core/registry"
+require "binder_core/scanner"
+require "binder_core/config"
+require "binder_core/folder_context"
+require "binder_core/file_context"
+require "binder_core/file_ref"
+require "binder_core/definition"
+require "binder_core/asset"
+require "binder_core/parser"
+require "binder_core/defaults"
+require "binder_core/settings"
+require "binder_core/console"
+
+module BinderCore
+  
+  # Raised when a binder is defined with the same name as a previously-defined binder.
+  class DuplicateDefinitionError < RuntimeError; end
+  
+  # Raised when a context object is found to be invalid after it is expected to be fully configured
+  class InvalidContextError < RuntimeError; end
+  
+  def self.binders
+    @binders ||= BinderCore::Registry.new("Binder")
+  end
+  
+  def self.define(name, &config)
+    bndr = BinderCore::Binder.new(name, config)
+    binders.add( bndr );
+  end
+  
+  def self.binder_by_name(name)
+    binders[name]
+  end
+  
+  def self.compile(name)
+    binder = binder_by_name(name)
+    if binder then Compiler.compile binder end
+    binder
+  end
+end
+

data/spec/binder_core/asset_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe BinderCore::Asset do
+  let(:path)        { "pathto/image.jpg" }
+  let(:cxt_route)   { %w{work gallery} }
+  let(:asset)       { BinderCore::Asset.new path }
+  let(:base_url)    { "http://www.example.com" }
+  
+  before(:each) do
+    asset.set_route cxt_route
+    asset.base_url = base_url
+  end
+  
+  it "should have a file and a feed route" do
+    asset.file.path.should == path
+    asset.route.should == cxt_route
+  end
+  
+  it "should provide a feed_path string" do
+    asset.feed_path.should == [*cxt_route,"image"].join("/")
+  end
+  
+  it "should have the name of the file as its name by default" do
+    asset.name.should == "image"
+  end
+  
+  it "should change the feed path when the name changes" do
+    asset.name = "image_1"
+    asset.feed_path.should == [*cxt_route,"image_1"].join("/")
+  end
+  
+  it "should set the asset with_name()" do
+    asset.with_name("image_2")
+    asset.feed_path.should == [*cxt_route,"image_2"].join("/")
+  end
+  
+  it "should have a base_url property" do
+    asset.should respond_to(:base_url)
+    asset.base_url = "test"
+    asset.base_url.should == "test"
+  end  
+  
+  it "should have a asset_url property" do
+    asset.should respond_to(:asset_url)
+    asset.asset_url = "test"
+    asset.asset_url.should == "test"
+  end
+  
+  it "should create asset_url automatically when the route or the base_url is updated" do
+    asset.asset_url.should == File.join( base_url, [*asset.route,asset.file.full_name].join("/"))
+    new_route = asset.set_route ["feed","folder","folder2"]
+    asset.asset_url.should == File.join( base_url, [*new_route,asset.file.full_name].join("/"))
+    asset.base_url = new_base_url = "http://example2.com"
+    asset.asset_url.should == File.join( new_base_url, [*new_route,asset.file.full_name].join("/"))
+  end
+  
+  it "should not allow you to tamper with the route array directly" do
+    lambda { asset.route << "test" }.should raise_error(RuntimeError)
+  end
+  
+  it "should raise an exception when you try to assign an empty string as the asset name" do
+    expect { asset.with_name("") }.to raise_error( ArgumentError, "Asset name for '#{asset.file.path}' cannot be empty")
+  end
+end

data/spec/binder_core/binder_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe "Binder" do
+  before(:each) do
+    @name = :test
+    @data = {:test => "test value" }
+    @binder = BinderCore::Binder.new(@name)
+    @binder.raw = @data;
+  end
+  
+  it "should have a binder name" do
+    @binder.name.should == @name
+  end
+  
+  it "should has a console property" do
+    @binder.should respond_to(:console)
+    @binder.should respond_to(:init_console)
+  end
+  
+  it "should create another binder with a different name" do
+    name2 = :test2
+    binder2 = BinderCore::Binder.new(name2)
+    binder2.name.should == name2
+  end
+  
+  it "should have a config proc" do
+    @binder.config.should be_kind_of(Proc)
+  end
+  
+  it "should supply a data hash when raw is called" do
+    @binder.raw[:test].should == @data[:test]
+  end
+  
+  it "should call the user config block after its own configuration is done" do
+    path = "../content/test/"
+    binder = BinderCore::Binder.new(@name, lambda { |config| config.set_path( path ) } )
+    config = double("Config")
+    config.should_receive(:set_path).with(path).ordered
+    binder.config.call(config)
+  end
+  
+  it "should call Compiler.link_assets with the raw data object and return final compiled object with data and assets" do
+    @binder.raw = {:data => @data }
+    @binder.raw[:data].should == @data
+    BinderCore::Compiler.should_receive(:link_assets).with(@data).and_return(@data)
+    @binder.link_assets.should == {:data => @data, :assets => [] }
+  end
+end

data/spec/binder_core/compiler_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe BinderCore::Compiler do
+  describe "#compile" do
+    let(:binder)    { double("BinderMock").as_null_object }
+    let(:stack)     { double("StackMock").as_null_object }
+    let(:console)   { double("ConsoleMock", :stack => stack ) }
+    let(:config)    { double("ConfigMock").as_null_object }
+    let(:data)      { {:key => "value"} }
+    let(:assets)    { ["assets"] }
+    let(:file)      { double("FileContextMock", :data => data, :assets => assets) }
+    
+    before(:each) do
+      BinderCore::Scanner.should_receive(:scan) do |con| 
+        con.call(config) 
+        file
+      end
+    end
+    
+    after(:each) do
+      BinderCore::Compiler.compile binder
+    end
+    
+    it "should copy compiler settings from the global compiler defaults" do
+      settings = double("SettingsMock")
+      BinderCore::Settings.should_receive(:propegate).and_return settings
+      BinderCore::Console.should_receive(:new).with(settings).and_return console
+      binder.should_receive(:init_console).with(console)
+    end
+    
+    it "should assemble pre-config, default config, and user defined config procs" do
+      default = double("DefaultProcMock")
+      user = double("UserProcMock")
+      BinderCore::Default.should_receive(:config).and_return(default)
+      binder.should_receive(:config).and_return(user)
+      config.should_receive(:set_console)
+      default.should_receive(:call)
+      user.should_receive(:call)
+    end
+    
+    it "should add data to the binder raw property" do
+      binder.should_receive(:raw=).with({:data => data, :assets => assets })
+    end
+  end
+  
+  describe "#link" do
+    let(:asset_path) { "path/to/asset.jpg" }
+    let(:asset) { BinderCore::Asset.new(asset_path) }
+    let(:route) { ["work","gallery"] }
+    let(:base) { "http://www.example.com/binder/" }
+    let(:raw_data) { {:gallery => {:image => asset, :images => [asset,"not_asset",asset], :description => "This is a description"} } }
+    
+    before(:each) do
+      asset.set_route route
+      asset.base_url = base
+      @res = BinderCore::Compiler.link_assets(raw_data)
+    end
+    
+    it "should replace the asset objects within the nested gallery hash" do
+      @res[:gallery][:image].should == asset.asset_url
+    end
+    
+    it "should replace all assets within a nexted images array" do
+      @res[:gallery][:images].should == [asset.asset_url,"not_asset",asset.asset_url]
+    end
+    
+    it "should not effect the raw_data object" do
+      @res.should_not == raw_data
+    end
+  end
+  
+  describe "#configure" do
+    it "should call the Default.settings function" do
+      BinderCore::Default.should_receive(:settings)
+      BinderCore::Compiler.configure {}
+    end
+    
+    it "should configure the settings object" do
+      BinderCore::Settings.should_receive(:configure).twice
+      BinderCore::Compiler.configure do
+        config.base_asset_url = url
+        config.content_folder = path
+      end
+    end
+  end
+end
+
+describe BinderCore::Compiler::Iterator do
+  let(:itr) { BinderCore::Compiler::Iterator.new }
+  let(:arr) { ["a",1,{}] }
+  let(:hash) { {:key1 => arr[0], :key2 => arr[1], :key3 => arr[2] } }
+  
+  it "should iterate objects in an array" do
+    itr.init arr
+    i = 0
+    itr.count.should == arr.count
+    itr.has_next?.should be_true
+    while itr.has_next?
+      itr.next.should == arr[i]
+      i += 1
+    end
+  end
+  
+  it "should iterate of values in a hash" do
+    itr.init hash
+    i = 0
+    itr.count.should == arr.count
+    itr.has_next?.should be_true
+    while itr.has_next?
+      itr.next.should == arr[i]
+      i += 1
+    end
+  end
+  
+  it "should replace elements in a hash" do
+    itr.init hash
+    while itr.has_next?
+      itr.next
+      itr.replace "replaced"
+    end
+    hash.should == {:key1 => "replaced", :key2 => "replaced", :key3 => "replaced" }
+  end
+  
+  it "should replace elements in an array" do
+    itr.init arr
+    while itr.has_next?
+      itr.next
+      itr.replace "replaced"
+    end
+    arr.should == ["replaced","replaced","replaced"]
+  end
+end