binder_core 0.1.0

data/spec/binder_core/config_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+
+describe BinderCore::Config do
+  describe "setter methods" do
+    let(:context)       { BinderCore::FolderContext.new }
+    let(:config)        { BinderCore::Config.new context }
+    let(:mockcontext)   { double("ContextMock") }
+    
+    it "should set the path of the contexts dir object" do
+      config.set_path BINDER_DEFAULT_DIR
+      context.file.path.should === BINDER_DEFAULT_DIR
+    end
+
+    it "should add an array of definitions to its rules collection" do
+      context.rules.should == []
+      context.rules = [1,2,3]
+      config.set_rules [4,5,6]
+      context.rules.should == [1,2,3,4,5,6]
+    end
+    
+    it "should add an array of definitions to its parsers collection" do
+      context.parsers.should == []
+      context.parsers = [1,2,3]
+      config.set_parsers [4,5,6]
+      context.parsers.should == [1,2,3,4,5,6]
+    end
+
+    it "should create a definition, add it to the front of the parser list and return it" do
+      config.set_parsers []
+      Parsr = Class.new
+      defn = config.add_parser Parsr do |fcnxt|
+        true
+      end
+      context.parsers.first.should == defn
+    end
+
+    it "should create a definition, add it to the front of the rule list and return it" do
+      config.set_rules []
+      Parsr = Class.new
+      defn = config.add_rule Parsr do |fcnxt|
+        true
+      end
+      context.rules.first.should == defn
+    end
+
+    # the route needs to get passed in from the parent
+    ##  If there is no extension how are we going to deal with files of the same names but different
+    ##  extensions. (replace dot in extension with undescore? I think leaving the dot in is not a good idea)
+
+    it "should add and configure the route array" do
+      config.set_route ["test"]
+      context.route.should == ["test"]
+    end
+    
+    it "should add a blank data object to the context object" do
+      data = {}
+      config.set_data data
+      context.data.should === data
+    end
+    
+    it "should set an array as asset to the context object" do
+      assets = []
+      config.set_assets assets
+      context.assets.should === assets
+    end
+    
+    it "should set the console" do
+      console = double("Console")
+      context.should_receive(:console=).with(console)
+      config.set_console console
+    end
+    
+    it "should add a params to the params object without over-writing it" do
+      config.add_params :test => "value"
+      config.add_params :test2 => "value2"
+      config.params[:test3] = "value3"
+      config.params.should == {:test => "value", :test2 => "value2", :test3 => "value3"}
+      context.params.should == {:test => "value", :test2 => "value2", :test3 => "value3"}
+    end
+  end
+ 
+  
+  describe "#verify_context" do
+    let(:file)          { double("FileMock", :path => "some/path/", ) }
+    let(:context)       { double("FileContextMock", :file => file) }
+    let(:console)       { BinderCore::Console.new double("SettingsMock").as_null_object }
+    let(:config)        { BinderCore::Config.new context }
+    
+    before(:each) do
+      context.should_receive(:console=).with(console)
+      config.set_console console
+    end
+    
+    it "should raise an error when content does not validate" do
+      expect { config.verify_context }.to raise_error(BinderCore::InvalidContextError)
+    end
+    
+    it "should provide detailed error message when the context does not validate" do
+      expect { config.verify_context }.to raise_error(BinderCore::InvalidContextError,"Invalid file at path:some/path/")
+    end
+    
+    describe "#valid_file?" do
+      it "should accept a valid file/folder" do 
+        console.should_receive(:defaults).with(:folder_size_limit_mb).and_return(100)
+        config.send( :valid_file?, BINDER_DEFAULT_DIR)#.should be_true
+        console.errors.should == []
+        console.continue?.should be_true
+      end
+      it "should reject a non-existent file/folder" do
+        path = "/path/to/non/existent/folder/"
+        config.send( :valid_file?, path).should be_false 
+        console.errors[0][:message].should == "File path:#{path} does not exist"""
+        console.continue?.should be_false
+      end
+      it "should reject a file/folder you do not have permission to access" do 
+        unreadable_file_path = "/var/root"
+        if !File.exists?(unreadable_file_path)
+          raise "This test will not run on your system, change '/var/root' to an unreadable folder or file on YOUR system" 
+        end
+        config.send( :valid_file?,  unreadable_file_path ).should be_false 
+        console.errors[0][:message].should == "You do not have permission to access the file at path:#{unreadable_file_path}"
+        console.continue?.should be_false
+      end
+
+      it "should ensure the folder overall size is not larger than the max size" do
+        path = BINDER_DEFAULT_DIR
+        console.should_receive(:defaults).with(:folder_size_limit_mb).and_return(100)
+        config.send( :valid_file?, path).should be_true
+        console.should_receive(:defaults).with(:folder_size_limit_mb).and_return(0.001)
+        config.send( :valid_file?, path).should be_false
+        console.errors[0][:message].should == "File contents at path:#{path} is larger then the limit of 0.001MB"
+        console.continue?.should be_false
+      end
+    end
+
+    describe "#file_within_size_limit?" do
+      it "should return true for 5000 bytes" do
+        config.send(:file_within_size_limit?, 5000, BINDER_DEFAULT_DIR).should be_true
+      end
+      it "should return false for 1000 bytes" do
+        config.send(:file_within_size_limit?, 1000, BINDER_DEFAULT_DIR).should be_false
+      end
+    end
+  end
+  
+end

data/spec/binder_core/console_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe BinderCore::Console do
+  let(:asset_url) { "http://www.example.com/" }
+  let(:content_folder) { "/path/to/content/folder/" }
+  let(:settings) do 
+    c = BinderCore::Settings::Config.new
+    c.base_asset_url = asset_url
+    c.content_folder = content_folder
+    c.folder_size_limit_mb = 100
+    c
+  end
+  let(:console) { BinderCore::Console.new settings }
+  
+  # get/set defaults
+  it "should provide access to default values through default method" do
+    console.defaults( :base_asset_url ).should == asset_url
+  end
+  
+  it "should allow a default property be updated by passing a hash to the default method" do
+    newurl = "http://example.com/binder/"
+    newpath = "/new/path/to/content/"
+    console.defaults :base_asset_url => newurl, 
+                    :content_folder => newpath
+    
+    console.defaults( :base_asset_url ).should == newurl
+    console.defaults( :content_folder ).should == newpath
+  end
+  
+  # log message
+  it "should add to the log when .log is called with a param and return the log array when no params" do
+    console.log "log"
+    console.log "captains"
+    console.log.should == ["captains","log"]
+  end  
+  
+  # log warning
+  it "should add to the warning log and return the warnings log array" do
+    console.warnings.should == []
+    console.warn "now"
+    console.warn "careful"
+    console.warnings.should == ["careful","now"]
+  end
+  
+  # log error and stop process
+  it "should log and error and change continue? to false" do
+    console.continue?.should be_true
+    console.errors.should == []
+    console.error "oh crap!"
+    console.errors.should == [ :message => "oh crap!",:stack => [] ]
+    console.continue?.should be_false
+  end
+  
+  # stack object > add, trace, clear
+  it "shoud have a stack object" do
+    console.stack.should be_kind_of BinderCore::Debug::Stack
+  end
+  
+ 
+end

data/spec/binder_core/debug/stack_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe BinderCore::Debug::Stack do
+  let(:stack)     { BinderCore::Debug::Stack.new }
+  let(:route)     { ["example","route"] }
+  let(:path)      { "arbitary/path/to/file/or/folder" }
+  let(:file_ref)  { double("FileRef", :path => path)  }
+  let(:folder)    { double("FolderContext", :file => file_ref, :class => "FolderContext" ) }
+  let(:file)      { double("FileContext", :file => file_ref, :class => "FileContext" ) }
+  let(:parser)    { double("Parser", :file => file_ref, :class => "Parser" ) }
+
+  describe "creating entries from folder, file and parser objects" do
+    it "should add a folder, file and parser and return a configured entry object" do
+      def test_entry(e,cl)
+        e.route.should == route
+        e.file_path.should == path
+        e.class_name.should == cl
+      end
+      
+      entry = stack.add_folder route, folder
+      test_entry entry, "FolderContext"
+      entry = stack.add_file route, file
+      test_entry entry, "FileContext"
+      entry = stack.add_file route, parser
+      test_entry entry, "Parser"
+    end
+  end
+  
+  describe "#trace" do
+    before(:each) do
+      cur_rt = []
+      ["a","b"].each do |e|
+        cur_rt << e
+        stack.add_folder  cur_rt, folder
+        stack.add_file    cur_rt, file
+        stack.add_parser  cur_rt, parser
+      end
+      cur_rt = ["a","c"]
+      stack.add_folder  cur_rt, folder
+      stack.add_file    cur_rt, file
+      stack.add_parser  cur_rt, parser
+      
+      @trace = stack.trace
+    end
+    
+    it "should provide a stack trace of the right length" do
+      @trace.length.should == 6
+    end
+    
+    it "should order them most recent first" do
+      # first check the routes are in the correct order
+      @trace.slice(0,3).each { |e| e.route.should == ["a","c"] }
+      @trace.slice(3,3).each { |e| e.route.should == ["a"] }
+      # now check the classes
+      class_order = [parser.class, file.class, folder.class]
+      count = 0
+      @trace.each do |e|
+        e.class_name.should == class_order[ count%class_order.length ]
+        count += 1
+      end
+    end
+  end
+end
+
+describe BinderCore::Debug::Stack::Entry do
+  let(:entry) { BinderCore::Debug::Stack::Entry.new }
+  
+  context "has required properties" do
+    subject { entry }
+    it { should respond_to(:route) }
+    it { should respond_to(:file_path) }
+    it { should respond_to(:class_name) }
+  end
+  
+  context "formating for display" do
+    let(:route) { ["example","work","gallery"] }
+    let(:path) { "/path/to/some/file" }
+    let(:clname) { "BinderCore::FileContext" }
+    
+    before(:each) do
+      entry.route = route
+      entry.file_path = path
+      entry.class_name = clname
+    end
+    
+    it "should override to_s with pretty output" do
+      entry.to_s.should == "#{clname} at route:(#{route.join(',')}) to file:#{path}"
+    end
+  end
+end

data/spec/binder_core/defaults_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe BinderCore::Default do
+  describe "#settings" do
+    it "should set the default values to all the settings" do
+      config = double("MockConfig")
+      BinderCore::Settings.should_receive(:config).exactly(4).times.and_return(config)
+      config.should_receive(:base_asset_folder=).with("")
+      config.should_receive(:base_asset_url=).with("")
+      config.should_receive(:content_folder=).with("")
+      config.should_receive(:folder_size_limit_mb=).with(100)
+      BinderCore::Default.settings
+    end
+  end
+  describe "#config" do
+    let(:config) { double("ContextConfig").as_null_object }
+    let(:config_proc) { BinderCore::Default.config}
+  
+    after(:each) do
+      config_proc.call( config )
+    end
+  
+    it "should add a null parser object" do
+      config.should_receive(:add_parser).with(BinderCore::NullParser)
+    end
+  
+    it "should add a text parser object" do
+      config.should_receive(:add_parser).with(BinderCore::TextParser)
+    end
+
+    it "should add a folder parser object" do
+      config.should_receive(:add_parser).with(BinderCore::FolderParser)
+    end
+  
+    it "should add an asset parser object for images" do
+      config.should_receive(:add_parser).with(BinderCore::AssetParser)
+    end
+    
+    it "should add a null parser object for files to be skipped" do
+      config.should_receive(:add_rule).with(BinderCore::NullParser)
+    end
+  end
+end

data/spec/binder_core/definition_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe BinderCore::Definition do
+   let(:klass) { Class.new }
+   let(:test) { lambda { |context| true } }
+   let(:definition) { BinderCore::Definition.new klass, test }
+   
+   it "should have a test method" do
+     definition.should respond_to(:test)
+   end
+   
+   it "should return a the Class from the test method, since the test returned true" do
+     definition.test(nil).should == klass
+   end
+   
+   it "should return nothing if the test proc eval'd to false" do
+     defn = BinderCore::Definition.new klass, lambda { |context| false }
+     defn.test(nil).should be_nil
+   end
+end

data/spec/binder_core/file_context_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe BinderCore::FileContext do
+  
+  let(:raw) { {:data => {:test => "value"}, :assets => {"work/gallery/image_1" => "pathto/image.jpg"}} }
+  let(:context) do 
+    BinderCore::FileContext.new
+  end
+  let(:defaults) { {:base_asset_url => ASSET_BASE_URL } }
+  let(:console) { double("ConsoleMock" ).as_null_object }
+  
+  before(:each) do
+    context.file = BinderCore::FileRef.new File.join( BINDER_DEFAULT_DIR,"work", "gallery", "image.jpg") 
+    context.route = %w{work gallery}
+    context.console = console
+  end
+  
+  it "should have a data property which is nil by default" do
+    context.should respond_to(:data)
+    context.data.should be_nil
+  end
+  
+  it "should have an empty array for assets by default" do
+    context.assets.should == []
+  end
+
+  it "should descent with a config block and call correct methods on the config class" do
+    cnfg = double("FolderConfig")
+    context.rules = ["rules"]
+    context.parsers = ["parsers"]
+    BinderCore::Scanner.should_receive(:descend) do |config|
+      config.call(cnfg)
+      raw
+    end
+    cnfg.should_receive(:set_rules).with(["rules"]).ordered
+    cnfg.should_receive(:set_parsers).with(["parsers"]).ordered
+    cnfg.should_receive(:set_assets).with([]).ordered
+    cnfg.should_receive(:set_console).with(console).ordered
+    cnfg.should_receive(:add_params).with({}).ordered
+    cnfg.should_receive(:set_path).with(context.file.path).ordered
+    cnfg.should_receive(:set_route).with(context.route.dup << context.file.name).ordered
+    cnfg.should_receive(:test).with("test").ordered
+    cnfg.should_receive(:verify_context).ordered
+    resp = context.descend { |config| config.test "test" }
+    resp.should == raw
+  end
+  
+  it "should pass its assets array on through the config object for population" do
+    cnfg = double("FolderConfig").as_null_object
+    BinderCore::Scanner.should_receive(:descend) do |config|
+      config.call(cnfg)
+      raw
+    end
+    cnfg.should_receive(:set_assets) do |arr|
+      arr << "test"
+    end
+    context.descend { |c|  }
+    context.assets.should == ["test"]
+  end
+  context "when registering an asset" do
+    let(:path) { "pathto/image.jpg" }
+    let(:name) { "image" }
+    let(:feed_path) { "#{context.route.join('/')}/#{name}" }
+    let(:asset) { asset = BinderCore::Asset.new path }
+    
+    it "should register an asset" do
+      context.register_asset( asset ).feed_path.should == feed_path
+      context.assets.should include asset
+    end
+    
+    it "should configure an asset" do
+      console.should_receive(:defaults) { |prop| defaults[prop] }
+      asset.should_receive(:route=).with(context.route)
+      asset.should_receive(:base_url=).with(defaults[:base_asset_url])
+      
+      context.register_asset( asset )
+    end
+  end
+end

data/spec/binder_core/file_ref_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe BinderCore::FileRef do
+  
+  describe "instance methods" do
+    let(:filename)  { "testfile" }
+    let(:ext)   { ".txt" }
+    let(:path)  { File.join( BINDER_DEFAULT_DIR, "test", "#{filename}#{ext}" ) }
+    let(:file)  { BinderCore::FileRef.new path }
+  
+    it "should have a path property set to path" do 
+      file.path.should == path
+    end
+  
+    it "should have a name of 'file'" do
+      file.name.should == filename
+    end
+  
+    it "shoudl have a full_name wiht the file name including the extension" do
+      file.full_name.should == filename+ext
+    end
+  
+    it "should have an extension of '.txt'" do
+      file.ext.should == ext
+    end
+  
+    it "should show it is not a directory" do
+      file.dir?.should be_false
+    end
+  
+    it "should show the current directory as a directory" do
+      file.path = BINDER_DEFAULT_DIR           
+      file.dir?.should be_true
+    end
+  
+    it "should provide an array of files contained within, empty array if none or file is not a directory" do
+      file.files.should == []
+      file.path = BINDER_DEFAULT_DIR
+      file.files.length.should == 1
+    end
+  end
+  
+end

data/spec/binder_core/folder_context_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+require "support/parsers/test_parsers"
+
+describe BinderCore::FolderContext do
+  describe "Initialization" do
+    context "properties" do
+      subject { BinderCore::FolderContext.new }
+      it { should respond_to(:parsers) }
+      it { should respond_to(:rules) }
+      it { should respond_to(:assets) }
+      it { subject.assets.should == [] }
+      it { should respond_to(:console) }
+      it { should respond_to(:console=) }
+      it { should respond_to(:data) }
+      it { subject.data.should be_nil }
+      it { should respond_to(:route) }
+      it { subject.route.should == [] }
+      it { should respond_to(:params) }
+      it { subject.params.should == {} }
+    end
+    
+    context "present its data" do
+      let(:context) { BinderCore::FolderContext.new }
+      it "should provide a native hash with data and assets through the raw method" do
+        context.data = data = {:test => "hash"}
+        context.assets = assets  = []
+        context.raw[:data].should == data
+        context.raw[:assets].should == assets
+      end
+    
+      it "should expand array values in a hash which have only one member" do
+        hash = {:key => ["value"], :key2 => ["value", "value2"]}
+        context.send(:expand_single_keys, hash).should == {:key => "value", :key2 => ["value", "value2"]}
+      end
+    end
+  end
+  describe "Parsing Folder Files" do
+    let(:context) { BinderCore::FolderContext.new }
+    let(:file_list) { ["test.txt"] }
+    let(:file) { double("FileRefMock", :files => file_list, :path => "some/path", ) }
+    let(:console) { double("ConsoleMock", :continue? => true) }
+    let(:file_context) { double("MockFileContext").as_null_object }
+    
+    before(:each) do
+      context.file = file
+      context.console = console
+    end
+    
+    it "should iterate through files" do
+      files = double("MockFilesList")
+      file.should_receive(:files).and_return(files)
+      files.should_receive(:each)
+      context.parse_files
+    end
+    
+    it "should stop loop if console.continue? flag is false" do
+      file.should_receive(:files).and_return(["test.txt", "test2.txt"])
+      BinderCore::Scanner.should_receive(:scan).at_least(:once).and_return(file_context)
+      console.should_receive(:continue?).twice.and_return( true )
+      context.parse_files
+      console.should_receive(:continue?).once.and_return( false )
+      context.parse_files
+    end
+    
+    it "should create a config proc and pass it to the scanner" do
+      config = double("ConfigMock")
+      
+      config.should_receive(:set_route).with([])
+      config.should_receive(:set_path).with(File.join(file.path,"test.txt"))
+      config.should_receive(:add_params).with({})
+      config.should_receive(:set_console).with(console)
+      config.should_receive(:set_rules).with([])
+      config.should_receive(:set_parsers).with([])
+      config.should_receive(:set_assets).with([])
+      config.should_receive(:verify_context)
+      
+      BinderCore::Scanner.should_receive(:scan) do |cbl|
+        cbl.call config
+        context
+      end
+      context.parse_files
+    end
+    
+    it "should add data from the returned parsed file context" do
+      context.should_receive(:add_data_from).with(file_context)
+      file_context.should_receive(:data).and_return({})
+      BinderCore::Scanner.should_receive(:scan).and_return(file_context)
+      context.parse_files
+    end
+    
+    it "should call expand single keys with the data hash once the file loop has completed" do
+      file.should_receive(:files).and_return([])
+      context.data = {}
+      context.should_receive(:expand_single_keys).once
+      context.parse_files
+    end
+    it "should return the raw data at the end" do
+      file.should_receive(:files).and_return([])
+      context.data = {:key => "value", }
+      context.assets = ["assets"]
+      context.parse_files.should == {:data => {:key => "value"}, :assets => ["assets"] }
+    end
+  end
+end

data/spec/binder_core/parser_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe BinderCore::Parser do
+ let(:context)  { double( "FileContext" ).as_null_object}
+ let(:parser)   { BinderCore::Parser.new context }
+  
+  it "should add data to the File Context" do
+    fdata = "test_content"
+    context.should_receive(:data=).with(fdata)
+    parser.add fdata
+  end
+  
+  it "should set the data key value when a second arg is sent to the add method" do
+    fdata = "test_value"
+    fkey = "test_key"
+    context.should_receive(:name=).with(fkey)
+    context.should_receive(:data=).with(fdata)
+    parser.add fdata, fkey
+  end
+  
+  it "should set the name of the context when key= is called" do
+    context.should_receive(:name=).with("key")
+    parser.key = "key"
+  end
+  
+  it "should provide access to the context file reference through the file method" do
+    context.should_receive(:file)
+    parser.file
+  end
+  
+  it "should have access to a params hash" do
+    context.should_receive(:params).and_return({:test => "test_value"})
+    parser.params[:test].should == "test_value"
+  end
+  
+  it "shoule have access to the context console" do
+    context.console = double("MockConsole")
+    parser.console.should == context.console
+  end
+  
+  it "should create a new asset" do
+    context.should_receive(:register_asset) do |a|
+      a.set_route %w{work gallery}
+      a
+    end
+    new_asset = parser.new_asset("/realpathto/image.jpg").with_name("image_1")
+    new_asset.should be_kind_of(BinderCore::Asset)
+    new_asset.feed_path.should == "work/gallery/image_1"
+  end
+  
+  it "should create a new asset with the default values for name and path" do
+    path = "pathto/image.jpg"
+    context.should_receive(:file).and_return( BinderCore::FileRef.new( path ))
+    context.should_receive(:register_asset) { |a| a }
+    new_asset = parser.new_asset
+    new_asset.file.path.should == path
+    new_asset.name.should == "image"
+  end
+  
+  it "should call descend with a config block and return data" do
+    bucket = {}
+    path = "path/to/folder/"
+    config = double("FolderConfig")
+    context.should_receive(:descend).and_yield(config).and_return({:data => bucket})
+    config.should_receive(:set_path).with(path)
+    resp = parser.descend do |c|
+      c.set_path path
+    end
+    resp.should == bucket
+  end
+  
+end

data/spec/binder_core/parsers/asset_parser_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe BinderCore::AssetParser do
+   let(:path)     { File.join(BINDER_DEFAULT_DIR, "test", "testfile.txt") }
+   let(:file)     { BinderCore::FileRef.new path }
+   let(:context)  { double("FileContext", :file => file ) }
+
+   it "should call descend into a folder and add the response to to file context data" do
+     parser = BinderCore::AssetParser.new context
+     context.should_receive(:register_asset).with(instance_of(BinderCore::Asset)) { |a| a }
+     context.should_receive(:data=).with(instance_of(BinderCore::Asset))
+     parser.parse
+   end
+end